中中中题库1_用copy的方法进行插入,注意此处insert没有into关键字。该方法的好处是可以设置cop

第二章 程序流程控制
容易
在循环中continue语句的作用是跳出当前循环。
错误

容易
在编写多层循环时，为了提高运行效率，应尽量减少内循环中不必要的计算。
正确

容易
如果仅仅是用于控制循环次数，那么使用for i in range(20)和for i in range(20, 40)的作用是等价的。
正确

容易
带有else子句的循环如果因为执行了break语句而退出的话，则会执行else子句中的代码。
错误

容易
对于带有else子句的循环语句，如果是因为循环条件表达式不成立而自然结束循环，则执行else子句中的代码。
正确

容易
在编写多层循环时，为了提高运行效率，应尽量减少内循环中不必要的计算。
正确

容易
以下关于循环控制语句描述错误的是哪一项？ （ ）。
A.Python中的for语句可以在任意序列上进行迭代访问，例如列表、字符串和元组。
B.在Python中if…elif…elif…结构中必须包含else子句。
C.在Python中没有switch-case的关键词，可以用if…elif…elif…来等价表达。
D.循环可以嵌套使用，例如一个for语句中有另一个for语句，一个while语句中有一个for语句等。

容易
for i in range(0,2): print (i) 上述程序的输出结果是： （ ）。
A.0 1 2
B.1 2
C.0 1
D.1

容易
下列程序共输出( )个值： 1. age = 23 2. start = 2 3. if age % 2 != 0: 4. start = 1 5. for x in range(start, age + 2, 2): 6. print(x)
A.10
B.16
C.12
D.14

容易
以下可以终结一个循环的执行的语句是（ ）。
A.break
B.if
C.input
D.exit

容易
下列 for 语句中，在 in 后使用不正确的是（ ）。 for var in : print（var）
A.set('str')
B.(1)
C.[1, 2, 3, 4, 5]
D.range(0, 10, 5)

容易
Python程序中假设字典d={'1':'male', '2':'female'}，如果语句中使用d[3]，则解释器将抛出（ ）错误信息。
A.NameError
B.IndexError
C.KeyError
D.TypeError
容易
Python程序中对于表达式123 + 'xyz'，解释器将抛出（ ）错误信息。
A.NameError
B.FileNotFoundError
C.SyntaxError
D.TypeError

容易
Python程序中假设列表s=[1,2,3]，如果语句中使用s[3]，则解释器将抛出（ ）错误信息。
A.NameError
B.IndexError
C.SyntaxError
D.TypeError

容易
以下for语句结构中，（ ）不能完成1~10的累加功能。
A.for i in range(10,0): total += i
B.for i in range(1,11): total += i
C.for i in range(10,0,-1): total += i
D.for i in (10,9,8,7,6,5,4,3,2,1): total += i

容易
下面if语句统计“成绩（score）优秀的男生以及不及格的男生”的人数，正确的语句为（ ）。
A.if (gender=="男" and score<60 or score>=90): n+=1
B.if (gender =="男" and score<60 and score>=90): n+=1
C.if (gender =="男" and (score<60 or score>=90)): n+=1
D.if (gender =="男" or score<60 or score>=90): n+=1
容易
用if语句表示如下分段函数： 下面不正确的程序段为（ ）。
A.if (x < 1): y = x * x - 2 * x+3 else: y = math.sqrt(x-1)
B.if (x < 1): y = x * x - 2 * x + 3 y = math.sqrt(x-1)
C.y = x * x - 2 * x+3 if (x >= 1): y = math.sqrt(x-1)
D.if (x < 1): y = x * x - 2 * x + 3 if (x >= 1): y = math.sqrt(x-1)
容易
下面程序段求两个数x和y中的大数，（ ）是不正确的。

A.maxNum= x if x>y else y
B.maxNum=math.max(x,y)
C.if (x>y): maxNum=x
D.if (y>=x): maxNum=y else: maxNum=ymaxNum=x

容易
执行下列Python语句将产生的结果是（ ）。 i = 1 if (i): print (True) else: print (False)
A.输出1
B.输出True
C.输出False
D.编译错误

容易
用if语句表示如下分段函数f(x)，下面不正确的程序是（ ）。 
A.if(x>=1):f=2*x+1 f=3*x/(x-1)
B.if (x>=1): f=2*x+1 if (x<1): f=3*x/(x-1)
C.f=2*x+1 if (x<1): f=3*x/(x-1)
D.if (x<1): f=3*x/(x-1) else: f=2*x+1

容易
执行下列Python语句将产生的结果是（ ）。 x = 2; y = 2.0 if(x==y): print("Equal") else: print("Not Equal")
A.Equal
B.Not Equal
C.编译错误
D.运行时错误
容易
当用户输入abc时，下面代码的输出结果是（ ）。 

try:
   n = 0
   n = input("请输入一个整数: ")
   def pow10(n):
      return n**10except:
   print("程序执行错误")
A.输出：abc
B.程序没有任何输出
C.输出：0
D.输出：程序执行错误

容易
当用户输入abc时，下面代码的输出结果是（ ）。 try: n = 0 n = int(input("请输入一个整数: ")) def pow10(n): return n**10 print(pow10(n)) except: print("程序执行错误")
A.abc
B.程序没有任何输出
C.0
D.程序执行错误

容易
执行以下程序，输入la，输出结果是（ ）。 la = 'python' try: s = eval(input('请输入整数： ')) ls = s*2 print(ls) except: print('请输入整数 ')
A.la
B.请输入整数
C.pythonpython
D.python

容易
以下程序的输出结果是（ ）。 s='' try: for i in range(1, 10, 2): s.append(i) except: print('error') print(s)
A.1 3 5 7 9
B.[1, 3, 5, 7, 9]
C.4, 6, 8, 10
D.error

容易
以下关于循环结构的描述，错误的是（ ）。
A.遍历循环使用for <循环变量> in <循环结构>语句，其中循环结构不能是文件
B.使用range()函数可以指定for循环的次数
C.for i in range(5)表示循环5次，i的值是从0到4
D.用字符串做循环结构的时候，循环的次数是字符串的长度
 正确
参考答案：
遍历循环使用for <循环变量> in <循环结构>语句，其中循环结构不能是文件
解析：
暂无解析
批注：
暂无评语
容易
执行以下程序，输入qp，输出结果是（ ）。 k = 0 while True: s = input('请输入q退出：') if s == 'q': k += 1 continue else: k += 2 break print(k)
+ 1.0 分
A.2
B.请输入q退出：
C.3
D.1
 正确
参考答案：
2
解析：
暂无解析
批注：
暂无评语
容易
关于 Python 的分支结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.分支结构使用 if 保留字
B.Python 中 if-else 语句用来形成二分支结构
C.Python 中 if-elif-else 语句描述多分支结构
D.分支结构可以向已经执行过的语句部分跳转
 正确
参考答案：
分支结构可以向已经执行过的语句部分跳转
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。 for s in "HelloWorld": if s=="W": continue print(s,end="")
+ 1.0 分
A.Hello
B.World
C.HelloWorld
D.Helloorld
 正确
参考答案：
Helloorld
解析：
暂无解析
批注：
暂无评语
容易
以下选项，不属于程序流程图基本元素的是（ ）。
+ 0.0 分
A.循环框
B.连接点
C.判断框
D.起始框
 错误
参考答案：
循环框
解析：
暂无解析
批注：
暂无评语
容易
关于结构化程序设计方法原则的描述，以下选项中错误的是（ ）。
+ 1.0 分
A.自顶向下
B.逐步求精
C.多态继承
D.模块化
 正确
参考答案：
多态继承
解析：
继承是面向对象方法的一个重要特征，是使用已有的类定义作为基础建立新类的定义技术。继承是指能够直接获得已有的性质和特征，而不必重复定义它们。
批注：
暂无评语
容易
关于结构化程序设计所要求的基本结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.重复（循环）结构
B.选择（分支）结构
C.goto 跳转
D.顺序结构
 正确
参考答案：
goto 跳转
解析：
暂无解析
批注：
暂无评语
容易
关于Python循环结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.Python通过for、while等保留字提供遍历循环和无限循环结构
B.遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等
C.break用来跳出最层for或者while循环，脱离该循环后程序从循环代码后继续执行
D.每个continue语句有能力跳出当前层次的循环
 正确
参考答案：
每个continue语句有能力跳出当前层次的循环
解析：
continue语句用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。
批注：
暂无评语
容易
以下选项中，不属于结构化程序设计方法的是（ ）。
+ 1.0 分
A.自顶向下
B.逐步求精
C.模块化
D.可封装
 正确
参考答案：
可封装
解析：
结构化程序设计方法的基本思想是将软件设计成相对独立、单一功能的模块组成的结构。结构化程序设计方法的4条原则是：①自顶向下；②逐步求精；③模块化；④限制使用goto语句。可封装是面向对象程序设计的特点之一。
批注：
暂无评语
容易
关于分支结构，以下选项中描述不正确的是（ ）。
+ 0.0 分
A.if语句中语句块执行与否依赖于条件判断
B.if语句中条件部分可以使用任何能够产生True和False的语句和函数
C.双分支结构有一种紧凑形式，使用保留字if和elif实现
D.多分支结构用于设置多个判断条件以及对应的多条执行路径
 错误
参考答案：
双分支结构有一种紧凑形式，使用保留字if和elif实现
解析：
双分支结构有一种紧凑形式，使用保留字if和else实现。
批注：
暂无评语
容易
以下选项中，不是Python语言基本控制结构的是（ ）。
+ 0.0 分
A.顺序结构
B.程序异常
C.循环结构
D.跳转结构
 错误
参考答案：
跳转结构
解析：
跳转结构不是Python语言的基本控制结构。
批注：
暂无评语
容易
下面代码的输出结果是（ ）。

for s in "HelloWorld":
    if s=="W":
    break
    print(s,end="")
+ 1.0 分
A.Helloorld
B.Hello
C.World
D.HelloWorld
 正确
参考答案：
Hello
解析：
break结束当前循环，不再判断执行循环的条件。
批注：
暂无评语
容易
下面代码的输出结果是（ ）。

    vlist=list(range(5))
    print(vlist)
+ 1.0 分
A.[0,1,2,3,4]
B.0 1 2 3 4
C.0,1,2,3,4,
D.0;1;2;3;4;
 正确
参考答案：
[0,1,2,3,4]
解析：
暂无解析
批注：
暂无评语
容易
关于Python循环结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.Python通过for、while等保留字构建循环结构
B.遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等
C.break用来结束当前当次语句，但不跳出当前的循环体
D.continue只结束本次循环
 正确
参考答案：
break用来结束当前当次语句，但不跳出当前的循环体
解析：
continue用来结束当前当次语句，但不跳出当前的循环体。
批注：
暂无评语
容易
下面代码的输出结果是（ ）。

for s in "HelloWorld":
    if s=="W":
        continue
    print(s,end="")
+ 1.0 分
A.Hello
B.World
C.HelloWorld
D.Helloorld
 正确
参考答案：
Helloorld
解析：
暂无解析
批注：
暂无评语
容易
关于 Python 的分支结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.分支结构使用 if 保留字
B.Python 中 if-else 语句用来形成二分支结构
C.Python 中 if-elif-else 语句描述多分支结构
D.分支结构可以向已经执行过的语句部分跳转
 正确
参考答案：
分支结构可以向已经执行过的语句部分跳转
解析：
暂无解析
批注：
暂无评语
容易
关于结构化程序设计所要求的基本结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.重复（循环）结构
B.选择（分支）结构
C.goto 跳转
D.顺序结构
 正确
参考答案：
goto 跳转
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。 

for i in range(10):
    if i%2==0:
        continue
    else:print(i, end=",")
+ 1.0 分
A.2,4,6,8,
B.0,2,4,6,8,
C.0,2,4,6,8,10,
D.1,3,5,7,9,
 正确
参考答案：
1,3,5,7,9,
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。

sum = 1.0for num in range(1,4):
    sum+=numprint(sum)
+ 1.0 分
A.6
B.7.0
C.1.0
D.7
 正确
参考答案：
7.0
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in "Summer": if i == "m": break print(i)
+ 1.0 分
A.M
B.mm
C.mmer
D.无输出
 正确
参考答案：
无输出
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for num in range(1,4): sum *= num print(sum)
+ 1.0 分
A.6
B.7
C.7.0
D.TypeError 出错
 正确
参考答案：
TypeError 出错
解析：
暂无解析
批注：
暂无评语
容易
以下关于 Python 的控制结构，错误的是（ ）。
+ 1.0 分
A.每个 if 条件后要使用冒号（：）
B.在 Python 中，没有 switch-case 语句
C.Python 中的 pass 是空语句，一般用作占位语句
D.elif 可以单独使用
 正确
参考答案：
elif 可以单独使用
解析：
暂无解析
批注：
暂无评语
容易
以下语句执行后a、b、c的值是（ ）。 a = "watermelon" b = "strawberry" c = "cherry" if a > b: c = a a = b b = c
+ 1.0 分
A.watermelon strawberry cherry
B.watermelon cherry strawberry
C.strawberry cherry watermelon
D.strawberry watermelon watermelon
 正确
参考答案：
strawberry watermelon watermelon
解析：
暂无解析
批注：
暂无评语
容易
结构化程序设计中，下面对goto语句使用描述正确的是（ ）。
+ 1.0 分
A.禁止使用goto语句
B.应避免滥用goto语句
C.goto语句最好用,不容易造成结构体程序混乱。
D.使用goto语句程序效率高
 正确
参考答案：
应避免滥用goto语句
解析：
暂无解析
批注：
暂无评语
容易
设 x = 10、y = 20，下列语句能正确运行结束的是（ ）。
+ 1.0 分
A.max = x >y ? x : y
B.if(x>y) print(x)
C.while True: pass
D.min = x if x < y else y
 正确
参考答案：
min = x if x < y else y
解析：
暂无解析
批注：
暂无评语
容易
以下代码段，不会输出“A，B，C，”的选项是（ ）。
+ 1.0 分
A.for i in range(3): print(chr(65+i),end=",")
B.for i in [0,1,2]: print(chr(65+i),end=",")
C.i = 0 while i < 3: print(chr(i+65),end= ",") i += 1 continue
D.i = 0 while i < 3: print(chr(i+65),end= ",") break i += 1
 正确
参考答案：
i = 0 while i < 3: print(chr(i+65),end= ",") break i += 1
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in "the number changes": if i == 'n': break else: print( i, end= "")
+ 1.0 分
A.the umber chages
B.thenumberchanges
C.theumberchages
D.the
 正确
参考答案：
the
解析：
暂无解析
批注：
暂无评语
容易
以下关于循环结构的描述，错误的是（ ）。
+ 1.0 分
A.遍历循环的循环次数由遍历结构中的元素个数来体现
B.非确定次数的循环的次数是根据条件判断来决定的
C.非确定次数的循环用 while 语句来实现，确定次数的循环用 for 语句来实现
D.遍历循环对循环的次数是不确定的
 正确
参考答案：
遍历循环对循环的次数是不确定的
解析：
暂无解析
批注：
暂无评语
容易
以下关于程序控制结构描述错误的是（ ）。
+ 1.0 分
A.分支结构包括单分支结构和双分支结构
B.双分支结构组合形成多分支结构
C.程序由三种基本结构组成
D.Python中能用分支结构写出循环的算法
 正确
参考答案：
Python中能用分支结构写出循环的算法
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in range(3): for s in "abcd": if s=="c": break print (s,end="")
+ 1.0 分
A.abcabcabc
B.aaabbbccc
C.aaabbb
D.ababab
 正确
参考答案：
ababab
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 t = "Python" print(t if t>="python" else "None")
+ 0.0 分
A.Python
B.python
C.t
D.None
 错误
参考答案：
None
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in "CHINA": for k in range(2): print(i, end="") if i == 'N': break
+ 1.0 分
A.CCHHIINNAA
B.CCHHIIAA
C.CCHHIAA
D.CCHHIINAA
 正确
参考答案：
CCHHIINAA
解析：
暂无解析
批注：
暂无评语
容易
以下关于分支和循环结构的描述，错误的是（ ）。
+ 1.0 分
A.python 的在分支和循环语句里使用例如 x<=y<=z 的表达式是合法的
B.分支结构的中的代码块是用冒号来标记的
C.while 循环如果设计不小心会出现死循环
D.双分支结构的 <表达式1> if <条件> else <表达式2> 形式，适合用来控制程序分支
 正确
参考答案：
双分支结构的 <表达式1> if <条件> else <表达式2> 形式，适合用来控制程序分支
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 a = 30 b = 1 if a >=10: a = 20 elif a>=20: a = 30 elif a>=30: b = a else: b = 0 print('a={}, b={}'.format(a,b))
+ 1.0 分
A.a=30, b=1
B.a=30, b=30
C.a=20, b=20
D.a=20, b=1
 正确
参考答案：
a=20, b=1
解析：
暂无解析
批注：
暂无评语
容易
以下关于程序控制结构描述错误的是（ ）。
+ 1.0 分
A.单分支结构是用if保留字判断满足一个条件，就执行相应的处理代码
B.双分支结构是用if-else根据条件的真假，执行两种处理代码
C.多分支结构是用if-elif-else处理多种可能的情况
D.在Python的程序流程图中可以用处理框表示计算的输出结果
 正确
参考答案：
在Python的程序流程图中可以用处理框表示计算的输出结果
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 x= 10 while x: x -= 1 if not x%2: print(x,end = '') else: print(x)
+ 1.0 分
A.86420
B.975311
C.97531
D.864200
 正确
参考答案：
864200
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。

for n in range(400,500):
    i = n // 100
    j = n // 10 % 10
    k = n % 10
    if n == i ** 3 + j ** 3 + k ** 3:
        print(n)
+ 1.0 分
A.407
B.408
C.153
D.159
 正确
参考答案：
407
解析：
暂无解析
批注：
暂无评语
容易
for或者while与else搭配使用时，关于执行else语句块描述正确的是（ ）。
+ 0.0 分
A.仅循环非正常结束后执行（以break结束）
B.循环正常结束后执行
C.总会执行
D.永不执行
 错误
参考答案：
循环正常结束后执行
解析：
暂无解析
批注：
暂无评语
容易
以下程序，对于输入qa，输出结果是（ ）。 k = 0 while True: s = input('请输入 q 退出： ') if s == 'q': k += 1 continue else: k += 2 break print(k)
+ 1.0 分
A.2
B.请输入 q 退出：
C.3
D.1
 正确
参考答案：
2
解析：
暂无解析
批注：
暂无评语
容易
执行以下程序，如果输入"93python22"，则输出结果是（ ）。 w = input('请输入数字和字母构成的字符串：') for x in w: if '0'<= x <= '9': continue else: w.replace(x,'') print(w)
+ 1.0 分
A.python9322
B.python
C.93python22
D.
 正确
参考答案：
93python22
解析：
暂无解析
批注：
暂无评语
容易
以下关于循环结构的描述，错误的是（ ）。
+ 1.0 分
A.遍历循环使用for <循环变量 > in <循环结构 >语句，其中循环结构不能是文件
B.使用 range()函数可以指定for 循环的次数
C.for i in range(5)表示循环 5 次， i 的值是从 0 到 4
D.用字符串做循环结构的时候，循环的次数是字符串的长度
 正确
参考答案：
遍历循环使用for <循环变量 > in <循环结构 >语句，其中循环结构不能是文件
解析：
暂无解析
批注：
暂无评语

第六章
容易
每个程序都具有的统一的运算模式是：D
A.顺序计算模式
B.输入输出模式
C.函数调用模式
D.IPO 模式

容易
以下关于数据维度的描述，错误的是（D ）。
A.采用列表表示一维数据，不同数据类型的元素是可以的
B.JSON 格式可以表示比二维数据还复杂的高维数据
C.二维数据可以看成是一维数据的组合形式
D.字典不可以表示二维以上的高维数据

容易
以下程序输出到文件text.csv中的结果是（B ）。 fo = open("text.csv",'w') x = [90,87,93] z = [] for y in x: z.append(str(y)) fo.write(",".join(z)) fo.close()
A.[90,87,93]
B.90,87,93
C.‘ [90,87,93] ’
D.‘ 90,87,93 ’

容易
以下关于文件的描述，错误的是（ B）。
A.二进制文件和文本文件的操作步骤都是“打开-操作-关闭”
B.open()打开文件之后，文件的内容并没有在内存中
C.open()只能打开一个已经存在的文件
D.文件读写之后，需要调用close()才能确保文件被保存在磁盘中

容易
以下关于CSV文件的描述，错误的选项是（ C）。
A.CSV文件可用于不同工具间进行数据交换
B.CSV文件格式是一种通用的，相对简单的文件格式，应用于程序之间转移表格数据。
C.CSV文件通过多种编码表示字符
D.CSV文件的每一行是一维数据，可以使用Python中的列表类型表示

容易
以下关于Python文件对象f的描述，错误的选项是（ A）。
A.f.closed文件关闭属性，当文件关闭时，值为False
B.f.writable()用于判断文件是否可写
C.f.readable()用于判断文件是否可读
D.f.seekable()判断文件是否支持随机访问

容易
关于Python文件的‘+’打开模式，以下选项正确的描述是（ B）。
A.追加写模式
B.与r/w/a/x一同使用，在原功能基础上增加同时读写功能
C.只读模式
D.覆盖写模式

容易
以下关于文件的描述错误的选项是（D ）。
A.readlines()函数读入文件内容后返回一个列表，元素划分依据是文本文件中的换行符
B.read()一次性读入文本文件的全部内容后，返回一个字符串
C.readline()函数读入文本文件的一行，返回一个字符串
D.二进制文件和文本文件都是可以用文本编辑器编辑的文件

容易
有一个文件记录了1000个人的高考成绩总分，每一行信息长度是20个字节，若想只读取最后10行的内容，不可能用到的函数是（D ）。
A.seek()
B.readline()
C.open()
D.read()

容易
以下程序输出到文件 text.csv中的结果是（ D）。 fo = open("text.csv",'w') x = [90,87,93] fo. write(",".join(str(x))) fo.close()
A.[90,87,93]
B.90,87,93
C.9,0,,, ,8,7,,, ,9,3,
D.[,9,0,,, ,8,7,,, ,9,3,]

容易
文件text.txt里的内容如下： QQ&Wechat Google & Baidu 以下程序的输出结果是（ ）。 fo = open("text.txt",'r') fo.seek(2) print(fo.read(8)) fo.close(D)
A.Wechat
B.&Wechat G
C.Wechat Go
D.&Wechat

容易
以下程序的输出结果是（D ）。 fo = open("text.txt",'w+') x,y ='this is a test','hello' fo.write('{}+{}\n'.format(x,y)) print(fo.read()) fo.close()
A.this is a test hello
B.this is a test
C.this is a test,hello.
D.this is a test+hello

容易
以下关于Python文件的描述，错误的是（ D）。
A.open函数的参数处理模式‘b’表示以二进制数据处理文件
B.open函数的参数处理模式‘+’表示可以对文件进行读和写操作
C.readline函数表示读取文件的下一行，返回一个字符串
D.open函数的参数处理模式‘a’表示追加方式打开文件，删除已有内容

容易
Python 文件读取方法read(size)的含义是（D ）。
A.从头到尾读取文件所有内容
B.从文件中读取一行数据
C.从文件中读取多行数据
D.从文件中读取指定size大小的数据,如果size为负数或者空，则读取到文件结束

容易
Python 文件只读打开模式是（ D）。
A.w 只写
B.x 
C.b 
D.r

容易
以下文件操作方法中，打开后能读取 CSV 格式文件的选项是（ ）。
A.fo = open("123.csv","w")
B.fo = open("123.csv","x")
C.fo = open("123.csv","a")
D.fo = open("123.csv","r")

容易
以下选项中，对文件的描述错误的是（ C）。
A.文件中可以包含任何数据内容
B.文本文件和二进制文件都是文件
C.文本文件不能用二进制文件方式读入
D.文件是一个存储在辅助存储器上的数据序列
容易
文件 book.txt 在当前程序所在目录内，其内容是一段文本：book，下面代码的输出结果是（C ）。 
txt = open("book.txt", "r")print(txt.read())
txt.close()
A.book.txt
B.txt
C.book
D.以上答案都不对

容易
以下选项中不是 Python 对文件的写操作方法的是（C ）。
+ 1.0 分
A.writelines
B.write 和 seek
C.writetext
D.write

容易
文件 book.txt 在当前程序所在目录内，其内容是一段文本：book，下面代码的输出结果是（D ）。 

txt = open("book.txt", "r");print(txt);
txt.close()
A.book.txt
B.txt
C.以上答案都不对
D.book
普通
在Python程序中，可以通过列表___访问命令行参数。___为Python脚本名，___为第一个参数名，___为第二个参数名。
参考答案：
第1空：sys.argv
第2空：argv[0]
第3空：argv[1]
第4空：argv[2]

Python可以使用函数_ open __打开文件。

普通
文件操作可以使用___方法关闭流，以释放资源。通常采用___语句，以保证系统自动关闭打开的流。
参考答案：
第1空：close
第2空：with

普通
打开随机文件后，可以使用实例方法___进行定位。
第1空：seek
容易
下列哪项不是Python中对文件的读取操作： （B ）。
A.read
B.readall
C.readlines
D.readline

容易
在读写文件之前，必须通过以下哪个方法创建文件对象： （ D）。
A.create
B.folder
C.File
D.open

容易
扩展库os中的方法remove()可以删除带有只读属性的文件。
错误

容易
使用内置函数open()且以”w”模式打开的文件，文件指针默认指向文件尾。
错误
容易
使用内置函数open()打开文件时，只要文件路径正确就总是可以正确打开的。
错误
容易
对文件进行读写操作之后必须显式关闭文件以确保所有内容都得到保存。
正确

容易
Python标准库os中的方法startfile()可以启动任何已关联应用程序的文件，并自动调用关联的程序。
正确

容易
Python标准库threading中的Lock、RLock、Condition、Event、Semaphore对象都可以用来实现线
正确

容易
二进制文件不能使用记事本程序打开。
错误

容易
使用普通文本编辑器软件也可以正常查看二进制文件的内容。
错误

容易
二进制文件也可以使用记事本或其他文本编辑器打开，但是一般来说无法正常查看其中的内容。
正确

容易
文件对象是可以迭代的。
正确

容易
以写模式打开的文件无法进读操作。
正确

普通
Python内置函数_ open()__用来打开或创建文件并返回文件对象。
容易
扩展库os中的方法remove()可以删除带有只读属性的文件。
错误
容易
使用内置函数open()且以”w”模式打开的文件，文件指针默认指向文件尾。
错误

容易
正则表达式元字符“\s”用来匹配任意空白字符。
正确
容易
正则表达式 元字符“\d”用来匹配任意数字字符。
正确
容易
正则表达式元字符“^”一般用来表示从字符串开始处进行匹配，用在一对方括号中的时候则表示反向匹配，不匹配方括号中的字符。
正确
容易
使用正则表达式对字符串进行分割时，可以指定多个分隔符，而字符串对象的split()方法无法做到这一点。
正确
容易
正则表达式对象的match()方法可以在字符串的指定位置开始进行指定模式的匹配。
正确
容易
已知x为非空字符串，那么表达式 ''.join(x.split()) == x 的值一定为True。
错误
容易
已知x为非空字符串，那么表达式 ','.join(x.split(',')) == x 的值一定为True。
正确
容易
正则表达式模块re的match()方法是从字符串的开始匹配特定模式，而search()方法是在整个字符串中寻找模式，这两个方法如果匹配成功则返回match对象，匹配失败则返回空值None。
正确
容易
如果需要连接大量字符串成为一个字符串，那么使用字符串对象的join()方法比运算符+具有更高的效率。
正确

容易
Python字符串方法replace()对字符串进行原地修改。
错误
容易
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是（ ）。
A.a[0] = 'e'
C.replace('a', 'e')
D.a = 'e' + a[1:]
E.a[1] = 'e'
容易
字符串函数strip()的作用是什么？ （ ）。
A.按照指定字符分割字符串为数组
B.连接两个字符串序列
C.去掉字符串两侧空格或指定字符
D.替换字符串中特定字符
容易
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？ （ ）。
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
容易
执行以下两条语句后，lst的结果是（ ）。 1. lst = [3, 2, 1] 2. lst.append(lst)
A.[3, 2, 1, [3, 2, 1]]
B.[3, 2, 1, […]]，其中“…”表示无穷递归
C.抛出异常
D.[3, 2, 1, lst]

在print函数的输出字符串中可以将（ ）作为参数，代表后面指定要输出的字符串。
A.%d
B.%c
C.%s
D.%t
普通
表达式 re.split('\.+', 'alpha.beta...gamma..delta') 的值为___。
 ['alpha', 'beta', 'gamma', 'delta']
普通
表达式 'apple.peach,banana,pear'.find('ppp') 的值为_-1__。
普通
表达式 'abcdefg'.split('d') 的值为___。
第1空：['abc', 'efg']
普通
表达式 ':'.join('1,2,3,4,5'.split(',')) 的值为___。
第1空：'1:2:3:4:5'
普通
表达式 'Hello world. I like Python.'.rfind('python') 的值为___。
第1空：-1
普通
表达式 'abcabcabc'.count('abc') 的值为___。
第1空：3
普通
表达式 'apple.peach,banana,pear'.find('p') 的值为___。
第1空：1
普通
正则表达式元字符___用来表示该符号前面的字符或子模式1次或多次出现。
第1空：+
普通
正则表达式元字符___用来表示该符号前面的字符或子模式0次或多次出现。
第1空：*
普通
表达式 'hello world, hellow every one'.replace('hello', 'hi') 的值为___。
第1空：'hi world, hiw every one'
普通
已知字符串 x = 'hello world'，那么执行语句 x.replace('hello', 'hi') 之后，x的值为___。
第1空：'hello world'
普通
假设正则表达式模块re已导入，那么表达式 re.sub('\d+', '1', 'a12345bbbb67c890d0e') 的值为___。
第1空：'a1bbbb1c1d1e'
普通
代码 print(re.match('^[a-zA-Z]+$','abcDEFG000')) 的输出结果为___。
第1空：None
普通
在设计正则表达式时，字符___紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时，匹配模式是“非贪心的”，匹配搜索到的、尽可能短的字符串。
第1空：?
普通
语句 print(re.match('abc', 'defg')) 输出结果为___。
第1空：None
普通
已知 x = 'a234b123c'，并且re模块已导入，则表达式 re.split('\d+', x) 的值为___。
第1空：['a', 'b', 'c']
普通
表达式 ''.join('asdssfff'.split('sd')) 的值为___。
第1空：'assfff'
普通
表达式 ''.join(re.split('[sd]','asdssfff')) 的值为___。
第1空：'afff'
普通
假设re模块已导入，那么表达式 re.findall('(\d)\\1+', '33abcd112') 的值为___。
第1空：['3', '1']
普通
表达式 'a'.join('abc'.partition('a')) 的值为___。
第1空：'aaabc'

1 . 
通过对象不能调用类方法和静态方法。
错误 
2 . 
在Python中可以为自定义类的对象动态增加新成员。
正确 
3 . 
Python类不支持多继承。
错误 
4 . 
Python类的构造函数是__init__()。
正确 
5 . 
定义类时，在一个方法前面使用@classmethod进行修饰，则该方法属于类方法。
正确 
6 . 
定义类时，在一个方法前面使用@staticmethod进行修饰，则该方法属于静态方法。
正确 
7 . 
在类定义的外部没有任何办法可以访问对象的私有成员。
错误 
8 . 
在Python中定义类时，如果某个成员名称前有2个下划线则表示是私有成员。
正确 
9 . 
定义类时实现了__eq__()方法，该类对象即可支持运算符==。
正确 
10 . 
定义类时实现了__pow__()方法，该类对象即可支持运算符**。
正确 
11 . 
定义类时如果实现了__contains__()方法，该类对象即可支持成员测试运算in。
正确 
12 . 
定义类时如果实现了__len__()方法，该类对象即可支持内置函数len()。
正确 
13 . 
在Python中定义类时实例方法的第一个参数名称不管是什么，都表示对象自身。
正确 
14 . 
在Python中定义类时实例方法的第一个参数名称必须是self。
错误 
15 . 
Python支持多继承，如果父类中有相同的方法名，而在子类中调用时没有指定父类名，则Python解释器将从左向右按顺序进行搜索。
正确 
16 . 
如果定义类时没有编写析构函数，Python将提供一个默认的析构函数进行必要的资源清理工作。
正确 
17 . 
在派生类中可以通过“基类名.方法名()”的方式来调用基类中的方法。
正确 
18 . 
对于Python类中的私有成员，可以通过“对象名._类名__私有成员名”的方式来访问。
正确 
19 . 
在面向对象程序设计中，函数和方法是完全一样的，都必须为所有参数进行传值。
错误 
20 . 
Python中没有严格意义上的私有成员。
正确 
21 . 
在Python中定义类时，运算符重载是通过重写特殊方法实现的。例如，在类中实现了__mul__()方法即可支持该类对象的**运算符。
错误 
22 . 
Python中一切内容都可以称为对象。
正确 
23 . 
定义类时所有实例方法的第一个参数用来表示对象本身，在类的外部通过对象名来调用实例方法时不需要为该参数传值。
正确 
24 . 
继承自threading.Thread类的派生类中不能有普通的成员方法。
错误 
25 . 
在Python中可以为自定义类的对象动态增加新成员。
正确  
26 . 
Python类不支持多继承。
错误 
41 . 
在派生类中可以通过“基类名.方法名()”的方式来调用基类中的方法。
正确 
73 . 
Python定义私有变量的方法为（ ）。
A. 使用__private 关键字
B. 使用public关键字
C. 使用__xxx__定义变量名
D. 使用__xxx定义变量名
74 . 
关于面向对象的继承，以下选项中描述正确的是（ ）。
A. 继承是指一组对象所具有的相似性质
B. 继承是指类之间共享属性和操作的机制
C. 继承是指各对象之间的共同性质
D. 继承是指一个对象具有另一个对象的性质
76 . 
在面向对象方法中，一个对象请求另一对象为其服务的方式是通过发送（ ）。
A. 调用语句
B. 命令
C. 口令
D. 消息
77 . 
关于面向对象的程序设计，以下选项中描述错误的是（ ）。
A. 面向对象方法可重用性好
B. Python 3解释器内部采用完全面向对象的方式实现
C. 用面向对象方法开发的软件不容易理解
D. 面向对象方法与人类习惯的思维方法一致
80 . 
阅读下面Python语句，请问输出结果是什么？ from copy import * d1 = {'a':[1,2], 'b':2}; d2 = deepcopy(d1); d1['a'][0]=6 sum = d1['a'][0] + d2['a'][0]; print(sum)
7
81 . 
下列Python语句的程序运行结果为________。 list1=[1,2,3]; list2=[3,4,5];dict1={'1':list1, '2':list2};dict2=dict1.copy() dict1['1'][0]=15; print(dict1['1'][0] + dict2['1'][0])
30
82 . 
阅读下面Python语句，请问输出结果是什么？

d1 = {'a':[1,2], 'b':2}; d2= d1.copy(); d1['a'][0]=6
sum = d1['a'][0] + d2['a'][0]; print(sum)
12
83 . 
下列Python语句的程序运行结果为________。 class account: def __init__(self, id, balance): self.id = id; self.balance = balance def deposit(self, amount): self.balance += amount def withdraw(self, amount): self.balance -= amount acc1 = account('1234', 100); acc1.deposit(500) acc1.withdraw(200); print(acc1.balance)
400
 
84 . 
Python类体中，___是一个类方法，创建对象时调用，返回当前对象的一个实例，一般无需重载该方法。___方法即构造函数（构造方法），用于执行类的实例的初始化工作。对象创建后调用，初始化当前对象的实例，无返回值。___方法即析构函数，用于实现销毁类的实例所需的操作，如释放对象占用的非托管资源。
__new__ 、__init__ 、__del__
85 . 
在Python中，实例变量在类的内部通过___访问，在外部通过对象实例访问。
self
86 . 普通 （1分）
面向对象的程序设计具有三个基本特征：___、___和___。
封装、继承、多态
87 . 
Python语句序列“x='123';print(isinstance(x, int))”的运行结果为___。
False

88 . 
在Python中创建对象后，可以使用___运算符来调用其成员。
.

第一章
1 . 不同版本的Python不能安装到同一台计算机上。
错误 
2.一般来说，Python扩展库没有通用于所有版本Python的，安装时应选择与已安装Python的版本对应的扩展库。
正确 
3 . 可以使用py2exe或pyinstaller等扩展库把Python源程序打包成为exe文件，从而脱离Python环境在Windows平台上运行。
正确 
4.Python程序只能在安装了Python环境的计算机上以源代码形式运行。
错误 
5.使用print()函数无法将信息写入文件。
错误 
11 . pip命令也支持扩展名为.whl的文件直接安装Python扩展库。
正确 
12 . 在任何时刻相同的值在内存中都只保留一份。
错误 
13 . Python采用的是基于值的自动内存管理方式。
正确 
14 . 
Python 3.x和Python 2.x唯一的区别就是：print在Python 2.x中是输出语句，而在Python 3.x中是输出函数。
错误 
15 .在Windows平台上编写的Python程序无法在Unix平台运行。
错误 
17 . Python是一种跨平台、开源、免费的高级动态编程语言。
正确 
18 . Python 3.x完全兼容Python 2.x。
错误 
19 .一般来说，Python扩展库没有通用于所有版本Python的，安装时应选择与已安装Python的版本对应的扩展库。
正确 
20 .可以使用py2exe或pyinstaller等扩展库把Python源程序打包成为exe文件，从而脱离Python环境在Windows平台上运行。
正确 
21 . Python程序只能在安装了Python环境的计算机上以源代码形式运行。
错误 
30 . 在任何时刻相同的值在内存中都只保留一份。
错误 
39 . 使用pip工具查看当前已安装Python扩展库列表的完整命令是_ pip list__。
40 . 使用pip工具升级科学计算扩展库numpy的完整命令是__ pip install --upgrade numpy_。
42 . 在IDLE交互模式中浏览上一条语句的快捷键是_ Alt+P __。
43 . Python程序文件扩展名主要有_ py __和__pyw_两种，其中后者常用于GUI程序。
44 . Python源代码程序编译后的文件扩展名为__ pyc_。
45 . Python安装扩展库常用的是_pip__工具。
64 . 容易 （1分）
算法是指（D ）。
A.数学的计算公式
B. 程序设计语言的语句序列
C. 问题的精确描述
D. 解决问题的精确步骤     
65 . 
下列关于程序设计语言的描述，正确的是（ B）。
A. 机器语言要通过编译才能被计算机接受
B. 早期人们使用机器语言编写计算机程序
C. 机器语言又称为高级语言
D. 现在人们普遍使用机器语言编写计算机程序
66 . 
使用（B）函数接收用输入的数据。
A. accept （）
B. input （）
C. readline（）
D. login（）
67 . 
Python脚本文件的扩展名为（B ）。
A. .python
B. .py
C. .pt
D. .pg
68 . 
下面不属于python特性的是（C ）。
A. 简单易学
B. 开源的免费的
C. 属于低级语言
D. 高可移植性
69 . 
利用pip命令查看pip常用帮助信息的选项是_-h 或者 –help__。
70 . 
开发和运行Python程序一般包括_文件式__和__交互式_两种方式。
71 . 
将源文件转换成机器语言一般有以下两种转换方法：_编译__和_解释_。
72 . 
高级编程语言根据执行机制不同可以分成静态语言和脚本语言两类。采用编译方式执行的语言属于__静态语言_，采用解释方式执行的语言属于_脚本语言__。
73 . 
高级编程语言根据执行机制不同可以分成静态语言和脚本语言两类。C、C++、C#、Java等程序设计语言属于_静态语言__，Python程序设计语言属于__脚本语言_。
74 . 
编程语言分为低级语言和高级语言两类，其中，机器语言和汇编语言属于__低级语言_，Python属于_高级语言__。
75 . 
结构化程序设计通常采用_自顶向下（Top-Down）__、_逐步求精（Stepwise Refinement）__的程序设计方法。
76 . 
计算思维的本质是_抽象（Abstraction）__和__自动化（Automation）_。
77 . 
在Python程序中导入sys模块后，可以通过列表___访问命令行参数。___表示Python脚本名；___表示第一个参数。
sys.argv 、argv[0] 、argv[1]
78 . 
在Python解释器中使用___函数可以进入帮助系统；键入___命令，可以退出帮助系统。
help()或者help 、quit
79 . 
Python程序打包和发布最常用的是第三方的扩展包_ PyInstaller__，它是用于将Python源程序生成直接运行的程序。
80 . 
要关闭Python解释器，可以使用___命令或者快捷键___。
quit() 、Ctrl+Z
81 . 
在Python内置集成开发环境IDLE中，可以使用快捷键__ F5_，运行当前打开的源代码程序。
82 .
Python注释以符号__#_开始，到行尾结束。
83 . 
Python语言是一种解释型、面向_对象__的计算机程序设计语言。
84 . 
用户程序编写的Python程序（避免使用依赖于系统的特性），无需修改就可以在任何支持Python的平台上运行，这是Python的__可移植性_特性。
85 . 
Python 3.4以后的版本中，___库用于安装管理Python扩展包，___库用于发布Python包。
pip 、setuptools
86 . 
在Python解释器中交互式执行Python代码的过程一般称之为（D ）。
A. FIFO
B. REPT
C. IPO
D. REPL
87 . 
在Python解释器中同时运行多个以逗号分隔的表达式，返回结果为（B ）。
A. 列表
B. 元组
C. 逗号分隔的结果
D. 空格分隔的结果
88 . 
以下程序设计语言中，C语言属于（A ）的编程语言。
A. 面向过程
B. 面向对象
C. 函数式
D. 逻辑式
89 . 
以下程序设计语言中，（A ）属于脚本语言。
A. Python
B. Java
C. C++
D. C#
91 . 容易 （1分）
以下程序设计语言中，Java、C#、C++等属于（ B）的编程语言。
A. 面向过程
B. 面向对象
C. 函数式
D. 逻辑式
92 . 
Python解释器环境中，用于表示上一次运算结果的特殊变量为（B ）。
A. :
B. _
C. >
D. #
93 . 
（ A）是Python官方的扩展库索引，所有人都可以下载第三方库或上传自己开发的库到其中。
A. PyPI
B. PyPy
C. Pydev
D. pip
94 . 
下列选项中，（A ）实现是最常用的Python版本，也称之为ClassicPython。
A. CPython
B. Jython
C. IronPython
D. PyPy
95 . 
Python内置的集成开发工具是_（ D）_。
A. PythonWin
B. Pydev
C. IDE
D. IDLE
96 . 
Python解释器的提示符为（C ）_。
A. >
B. >>
C. >>>
D. #
98 . 
下列选项中，不属于Python特点的是（B ）。
A. 面向对象
B. 运行效率高
C. 可移植性
D. 免费和开源
99 . 
用Pyinstall工具把Python源文件打包成一个独立的可执行文件，使用的参数是（D ）。
A. -d
B. -L
C. -i
D. -F
100 . 
以下关于程序设计语言的描述，错误的选项是（ C）。
A. Python语言是一种脚本编程语言
B. 汇编语言是直接操作计算机硬件的编程语言
C. 程序设计语言经历了机器语言、汇编语言、脚本语言三个阶段
D. 编译和解释的区别是一次性翻译程序还是每次执行时都要翻译程序
101 . 
以下不属于Python的pip工具命令的选项是（ D）。
A. show
B. install
C. download
D. get
102 . 
执行后可以查看Python的版本的是（A ）。
A. import sys print(sys.version)
B. import sys print(sys.Version)
C. import system print(system.version)
D. import system print(system.Version)
103 . 
关于Python语言的特点，以下选项中描述错误的是（B ）。
A. Python语言是脚本语言
B. Python语言是非开源语言
C. Python语言是跨平台语言
D. Python语言是多模型语言
105 . 
以下选项中说法不正确的是（ A）。
A. 静态语言采用解释方式执行，脚本语言采用编译方式执行
B. C语言是静态语言，Python语言是脚本语言
C. 编译是将源代码转换成目标代码的过程
D. 解释是将源代码逐条转换成目标代码同时逐条运行目标代码的过程
106 . 
IDLE环境的退出命令是（ A）。
A. exit()
B. esc()
C. close()
D. 回车键
107 . 
以下选项中，不是Python语言特点的是（B ）。
A. 强制可读：Python语言通过强制缩进来体现语句间的逻辑关系
B. 变量声明：Python语言具有使用变量需要先定义后使用的特点
C. 平台无关：Python程序可以在任何安装了解释器的操作系统环境中执行
D. 黏性扩展：Python语言能够集成C、C++等语言编写的代码
108 . 
（D ）选项是使用 PyInstaller 库对 Python 源文件打包的基本使用方法。
A. pip -h
B. pip install <拟安装库名>
C. pip download <拟下载库名>
D. pyinstaller 需要在命令行运行 :\>pyinstaller <Python源程序文件名>
111 . 
以下选项不属于程序设计语言类别的是（D ）。
A. 机器语言
B. 汇编语言
C. 高级语言
D. 解释语言

    #编写一个计算减法的方法，当第一个数小于第二个数时，引发“被减数不能小于减数”的异常
'''def sub(a,b):
    if a<b:
        raise Exception("被减数不能小于减数")
    else:
        return a-b
try:
    sub(8,7)
except Exception as error:
    print("出错了，出错的内容是".forat(error))'''
#2.定义一个函数func(filename) filename:文件的路径。函数功能：打开文件，并且返回文件内容，最后关闭，用异常来处理可能发生的错误。
'''def func(filename):
    try:
        file = open(filename,encoding="utf-8")
    except Exception as error:
        print("出错了，出错的内容是{}".format(error))
    else:
        print(file.read())
        file.close()
func("c:/test.txt")'''
#3.编写一个函数，对用户输入的字符串进行检查，当长度大于8时，引发“字符串长度超过要求”的异常。
'''def checklen():
    try:
        st = input("请输入字符：")
        if len(st) > 8:
            raise Exception("字符串长度超过要求")
    except Exception as err:
        print(err)
    else:
        print("符合要求")
checklen()'''
#4.编写Python程序，建立一个名为”Student”的数据库，其中包含表user和course，user表中包含字段“name”、“age”、“mojor， couse
# course表中包含字段“iterature”、“math”、“Physics”，并插入几条记录，用SOLiteExpert查看结果。
'''import sqlite3
import os.path

class SQLiteDB(object):
    def __init__(self, dbname):
        try:
            self.conn = sqlite3.connect(os.path.abspath(dbname))
        except Exception as err:
            print(err)
        else:
            self.cursor = self.conn.cursor()

    def createTable(self, sql):
        try:
            self.cursor.execute(sql)
        except Exception as err:
            print(err)

    def insert(self, sql, parm):
        res = self.cursor.execute(sql, parm)
        self.conn.commit()

    def query(self, sql):
        try:
            self.cursor.execute(sql)
        except Exception as err:
            print(err)

    def show(self,sql):
        li = self.cursor.execute(sql)
        for row in li:
            print(row)

    def __del__(self):
        self.cursor.close()
        self.conn.close()

if __name__ == '__main__':
    db = SQLiteDB('D:/student.db')
    sql = 'create table user( name  varchar(10),age integer , major varchar(10))'
    db.createTable(sql)
    sql = 'create table course( Iterature integer,math integer,Physics integer)'
    db.createTable(sql)

    sql = "insert into user values (?,?,?)"
    doc = ['张三', 20, '计算机应用技术']
    db.insert(sql, doc)
    sql = "insert into course values (?,?,?)"
    doc = [95, 93, 98]
    db.insert(sql, doc)

    db.show('select * from user')
    db.show('select * from course')'''
#5.编写程序，打开任意的文本文件，读出其中内容，判断该文件中某些给定关键字如“中国”出现的次数。
'''with open("C:/test.txt","r",encoding="utf-8") as f:
    text = f.read()
    n = text.count("中国")
    print(n)'''
#6.编写程序，打开任意的文本文件，在指定的位置产生一个相同文件的副本，即实现文件的拷贝功能。
'''with open("C:/test.txt","r",encoding="utf-8") as f:
    text = f.read()
with open("D:/copy.txt","w",encoding="utf-8") as f:
    f.write(text)'''
#7.定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；
#包含一个可以计算圆柱体体积的方法。然后编写相关程序测试相关功能。
'''import math
class Cylinder:
    def __init__(self,r,h):
        self.r = r
        self.h = h
    def tiji(self):
        return self.r*self.r*math.pi*self.h
cl = Cylinder(6,10)
print(round(cl.tiji(),2))'''
#8.定义一个学生类，包括学号、姓名和出生日期三个属性（数据成员）；包括一个用于给定
#数据成员初始值的构造函数；包含一个可计算学生年龄的方法。编写该类并对其进行测试。
'''from datetime import datetime
class Student:
    def __init__(self,no,name,birthday):
        self.no = no
        self.name = name
        self.birthday = birthday
    def compute_age(self):
        t1 = datetime.strptime(self.birthday,"%Y%m%d")
        t2 = datetime.today()
        return t2.year - t1.year
s1 = Student("1010","张三","19901220")
print(s1.compute_age())'''
#9.设计一个程序，用两个文本框输入数值数据，用列表框存放“＋、－、×、÷、幂次方、余数”。
#用户先输入两个操作数，再从列表框中选择一种运算，即可在标签中显示出计算结果。
#实现简单加减乘除程序。使用两个单行文本框输入数字，使用列表框选择运算。
'''from tkinter import *
import tkinter as tk
root = Tk()
def callbutton2():
    a = float(num1.get())
    b = float(num2.get())
    print(lb.curselection())
    k = lb.get(lb.curselection())
    print(k)
    if k == "加":
        print(a+b)
        result["text"] = str(a+b)
    if k == "减":
        print(a-b)
        result["text"] = str(a-b)
    if k == "乘":
        print(a*b)
        result["text"] = str(a*b)
    if k == "除":
        print(a/b)
        result["text"] = str(a/b)
root.title("使用例子")
lab1 = Label(root,text = "请输入第一个数",width = 20)
lab1.pack()
num1 = tk.Entry(root)
num1.pack()
lab2 = Label(root,text = "请输入第二个数",width = 20)
lab2.pack()
num2 = tk.Entry(root)
num2.pack()
lb = Listbox(root)
lb.insert(END,"加")
lb.insert(END,"减")
lb.insert(END,"乘")
lb.insert(END,"除")
lb.pack()
b2 = Button(root,text = "计算",command = callbutton2,width = 20)
b2.pack()
result = Label(root,text = "结果",width = 6)
result.pack()
root.mainloop()'''
#10.创建一个数据库stuinfo，并在其中创建数据库表student，表中包含stuid(学号)、stuname（姓名）、birthday（出生日期）、sex（性别）、address（家庭地址）、rxrq（入学日期）6列，其中stuid设为主键，并添加5条记录。
#将所有记录的rxrq属性更新为2017-9-1。查询性别为“女”的所有学生的stuname和address字段值.
'''import sqlite3
con=sqlite3.connect("D:/student.db")
cur=con.cursor()
cur.execute("DROP table book")
con.execute("create table book(stuid primary key,stuname varchar(20),birthday integer(20),sex varchar(20),address varchar(20),rxrq integer(20))")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(1,'张一',19980301,'男','黄河路1号',20160901)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(2,'张二',19980302,'女','黄河路2号',20160902)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(3,'张三',19980303,'男','黄河路3号',20160903)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(4,'张四',19980304,'男','黄河路4号',20160904)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(5,'张五',19980305,'女','黄河路5号',20160905)")
print('记录计入完成')
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
    print(row)
print('记录更新完成')
cur.execute("Update book set rxrq=20170901")
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
    print(row)
print('性别为女的名字和地址信息为：')
cur.execute('select stuname,sex,address from book')
values = cur.fetchall()
for row in values:
    if row[1]=='女':
        print(row[0],row[2])
cur.close()
con.commit()
con.close()'''
#11.设计一个简单的某应用程序的用户注册窗口，填写注册姓名、性别、爱好信息，单击“提交”按钮，
#将出现消息对话框显示填写的信息。
'''from tkinter import *
from tkinter import messagebox
fields = ['姓名', '性别', '爱好']
entries = []
def fetch():
    content = ""
    for entry in entries:
        field = entry[0]
        text = entry[1].get()
        m = '%s: %s' % (field, text)
        content = content + m + "\n"
    messagebox.showinfo("注册信息", content)
def makeform(root, fields):
    global entries
    for field in fields:
        row = Frame(root)
        lab = Label(row, width=15, text=field, anchor='w')
        ent = Entry(row)
        row.pack(side=TOP, fill=X, padx=5, pady=5)
        lab.pack(side=LEFT)
        ent.pack(side=RIGHT, expand=YES, fill=X)
        entries.append((field, ent))
if __name__ == '__main__':
    root = Tk()
    root.title('Message')
    makeform(root, fields)
    b1 = Button(root, text='提交', command=fetch)
    b1.pack(side=LEFT, padx=45, pady=5)
    b2 = Button(root, text='退出', command=root.destroy)
    b2.pack(side=RIGHT, padx=45, pady=5)
    root.mainloop()'''
#12.设计表示正方体的类Cube，包括数据域lenOfEdge表示正方体棱长，构造方法创建
#私有数据域lenOfEdge（默认值为1）的正方体，定义其setLenOfEdge()方法和getLenOfEdge()方法，
#getArea()方法返回正方体表面积，getVolume()方法返回正方体体积。并编写测试程序，
#生成两个立方体对象，一个棱长为6，一个棱长为9，分别显示这两个立方体的表面积和体积。
'''class Cube:
    def __init__(self,el=1):
        self.len0fEdge = el
    def setLenOfEdge(self,el):
        self.LenOfEdge = el
    def getLenOfEdge(self):
        return self.LenOfEdge
    def getArea(self):
        return self.len0fEdge**2*6
    def getVolume(self):
        return self.len0fEdge**3
c1 = Cube(6)
c2 = Cube(9)
print(c1.getArea(),c1.getVolume())
print(c2.getArea(),c2.getVolume())'''
#13.设计表示一支股票的类Stock，定义表示股票名称（字符串类型）的数据域name、表示股票代码（字符串类型）
#的数据域id、表示当前股价（浮点数类型）的数据域curPrice、表示前一交易日收盘价（浮点数类型）的数据域pcPrice、
#数据域都定义为私有。定义返回股票名称的get方法、返回股票代码的get方法、获得/设置pcPrice的set和get方法、
#获得/设置curPrice的set和get方法，定义rateOfChange()方法返回当前股价相较前一日收盘价的变化率。
#实现这个类，并编写测试程序，生成一个名称为“ABC”、代码为“09001”的股票对象，其前一天收盘价为20.35，
#当前股价为20.95，输出其价格的变化率。
'''class Stock:
    def __init__(self,name,id,curPrice,pcPrice):
        self.__name = name
        self.__id = id
        self.__curPrice = curPrice
        self.__pcPrice = pcPrice
    def getname(self):
        return self.__name
    def getid(self):
        return self.__id
    def getcurPrice(self):
        return self.__curPrice
    def setcurPrice(self,cp):
        self.__curPrice = cp
    def getpcPrice(self):
        return self.__pcPrice
    def setpcPrice(self,pp):
        self.__pcPrice = pp
    def rateOfChange(self):
        return (self.__curPrice - self.__pcPrice)/self.__pcPrice
s = Stock("ABC","09001",20.95,20.35)
print(round(s.rateOfChange()*100,2),"%")'''
#14.从键盘输入一些字符，逐个把它们写到磁盘文件上，直到输入一个 # 为止。
'''with open('D:/test.txt','w') as f:
    flag = True
    while flag:
        s = input('请输入：')
        if s.endswith('#'):
            s = s[:-1]
            flag = False
        f.write(s+'\n')'''
#15.从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘文件test中保存。
'''with open('D:/test.txt','w') as f:
    s = input('请输入：').upper()
    f.write(s)'''
#16.用户输入一个目录和一个文件名，搜索该目录及其子目录中是否存在该文件。
#(获取用户的文件路径，用os.walk函数搜索)
'''import os
di = input("输入目录：")
fi = input("输入文件：")
path = os.walk(di)
for root,dir,file in path:
    if fi in file:
        print(fi,"找到了")
        break
    else:
        print(fi,"没找到")'''
#17.有两个磁盘文件A.txt和B.txt，各存放一行字符，请编写程序把这两个文件中的信息合并，
#并按字母顺序排列，输出到一个新文件C.txt。
'''with open('D:/copy.txt','r',encoding="utf-8") as f1, open('D:/test.txt','r') as f2, open('D:/C.txt','w') as f3:
    s1 = f1.readline()
    s2 = f2.readline()
    s3 = s1 + s2
    li = list(s3)
    li.sort()
    s3 = ' '.join(li)
    f3.write(s3)'''
#18. 把一个数字的list从小到大排序，写入文件，从文件中读出文件内容，然后反序，再追加到文件的下一行。
'''import random
list_num = [random.randint(1,100) for i in range(1,20)]
list_num.sort()
txt = ",".join(list(map(str,list_num)))
with open("D:/test.txt","w",encoding="utf-8") as f:
    f.write(txt)
with open("D:/test.txt","r+",encoding="utf-8") as f:
    list_num2 = f.read().split(",")
    list_num2.reverse()
    txt2 = ",".join(list(list_num2))
    f.write("\n")
    f.write(txt2)'''
#20. 统计123.txt文件中单词的个数，文件未找到，抛出异常。
'''try:
    with open("D:/copy.txt","r",encoding="utf-8") as f:
        text = f.read()
        li = text.split()
        print(len(li))
except FileNotFoundError as err:
    print(err)'''
#22.使用异常处理猜数字游戏，输入非整数，抛出异常
'''import random
n = random.randint(1,101)
while True:
    try:
        num = int(input("请输入数字："))
        if num == n:
            print("you guess correctly.")
            break
        elif num>n:
            print("you guess is large.")
        else:
            print("you guess is small.")
    except Exception as err:
        print(err)'''
#23.有下面的类属性：姓名、年龄、成绩列表[语文，数学，英语]，其中每门课成绩的类型为整数，类的方法如下所述：
#(1)获取学生的姓名。get_name()，返回类型：str。
#(2)获取学生的年龄。get_age()，返回类型：int。
#(3)返回3门科目中最高的分数。get_course()， 返回类型：int。
#类定义好之后，可以定义两个同学测试下:
#zm = Student('zhangming',20,[69,88,100])
#返回结果：
#zhangming
#20
#100
'''class Student:
    def __init__(self,name,age,score):
        self.name = name
        self.age = age
        self.score = score
    def get_name(self):
        return self.name
    def get_age(self):
        return self.age
    def get_score(self):
        return max(self.score)
zm = Student('zhangming',20,[69,88,100])
print(zm.get_name())
print(zm.get_age())
print(zm.get_score())'''
#24.请定义一个交通工具(Vehicle)的类，属性：速度(speed)、体积(size)等等。
#方法：移动move()、设置速度setSpeed(int speed)、加速speedUp()、减速speedDown()等等。
#实例化一个交通工具对象，通过方法初始化speed、size的值并且打印出来。另外调用加速减速的方法对速度进行改变。
'''class Vehicle:
    def __init__(self,speed,size):
        self.speed = speed
        self.size = size
    def move(self):
        print("前进")
    def setSpeed(self,n):
        self.speed = n
    def speedUp(self):
        self.speed +=10
        print("hasten,speed is",self.speed)
    def speedDown(self):
        self.speed -= 10
        print("deceleate,speed is",self.speed)
v = Vehicle(89,100)
v.speedUp()
v.speedDown()'''
#25.设计一个Person类，属性有姓名、年龄、性别，创建方法personInfo，打印这个人的信息；
#创建Student类，继承Person类，属性有学院college，班级class，重写父类PersonInfo方法，
#调用父类方法打印个人信息，将学生的学院、班级信息也打印出来。
'''class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def personInfo(self):
        print(self.name,self.age,self.gender)
class Student(Person):
    def __init__(self,name,age,gender,college,team):
        Person.__init__(self,name,age,gender)
        self.college = college
        self.team = team
    def personInfo(self):
        Person.personInfo(self)
        print(self.college,self.team)
s = Student("张三",23,"男","网络安全系","2021级")
s.personInfo()'''
#26.主动引发一个ValueError异常，捕获后输出“捕获ValueError.
try:
    raise ValueError
except ValueError:
    print("捕获ValueError")

 
1.面问对象万法中，继事是指(   )。
A.类之间共享属性和操作的机制
B.各对象之间的共同性质
C.一组对象所具有的相似性质
D.一个对象具有另一个对象的性质
正确答案
A.类之间共享属性和操作的机制
学生答案
A.类之间共享属性和损作的机制

2.Python定义私有变量的方法为()。
A.使用_private关键字
B.使用public关键字
C.使用_xxx_定义变量名

D.使用_xoo.定义变量名    √
正确答案
D.使用_xoox定义变量名
学生答案
D.使用_xoxx定义变量名

3.关于 import 引用，以下选项中描述错误的是(   )。

C.使用import turtle as t 引入 turtle库，取别名为t
 

+2.0分

+2.0分
 

 
4.(  )模块是python标准库中最常用的模块之一。通过它可以获取命令行参数，从而实现从程序外部向程序内部传递参数的功
 

+2.0分
 
能，也可以获取程序路径和当前系统平台等信息，

A.sys                                                                                               √
B.platform

C.math

D.time
正确答案
A.sys
学生答案
A.sys

5.表达式‘A′+32会抛出下面哪种异常(  )                                                                      +2.0分

A.TypeError                                                                                                  V
B.SyntaxError

C.ValueError

D.AttributeError

6.以下模块用来获取目标网页文本的是?

A.requests    √    

B.bs4    ×    
C.fake_useragent
D.pymysql
正确答案
A.requests
学生答案
B.bs4

7.以下模块用来获取html中特定标签内容的是?

A.requests    ×

C.fake_useragent

Dpymysql
正确答案
B.bs4
学生答案
A.requests

 
1.继承自threading.Thread 类的派生类中不能有普通的成员方法。
正确

错误
正确答案
错误
学生答案
错误

2.Python 中一切内容都可以称为对急。

错误
 

+1.0分

+1.0分
 
正确答案
正确
学生答案
正确

3.在面向对象程序设计中，函数和方法是完全一样的，都必须为所有参数进行传值。
正确

错误    √

正确答案
错误
学生答案
错误

 
4.Python 中没有严格意义上的私有成员。

正确    √

 

+1.0分
 

5.Python类的构造函数是_init_0。

正确    √

错误    ×
正确答案
正确
学生答案
错误

6.定义类时，在一个方法前面使用@dassmethod 进行修怖，则该方法属于类方法。                                            +1.0分

正确    √
错误

正确答案
正确
学生答案
正确

7.定义类时，在一个方法前面使用@staticmethod进行休息，则该方法属于静态方法。

正确    √

错误

8.执行语句 from  math  import  sin 之后，可以自接便用 sinO 幽数，例如sin(3)。

正确    √
错误

正确答案
正确
学生答案
正确

9.已知应用程序主窗口root  =tkinterTk0.那么 rootresizable(False.False)的作用是设置窗口在水平和垂直两个方向都不允许+1.0分
改变大小。

正确                                                                                                    √
错 误

正确答案
正确
学生答案
正确

10.使用tkinter.simpledialog  模块中的askinteger) 函数弹出对话框输入整数时，如果用户单击“取消”按钮返回，那么 askinteger)函数的返回值为0。
正确
错误    √

1.在Python中创建对象后，可以使用__运算符来调用其成员。
正确答案
学生答案

2.Python 包含了数量众多的模块， 通 过 语句，可以导入模块。并使用其定义的功能。
正确答案
import
学生答案
import

3.Python 中sys模块的__属性返回一个路径列表。
正确答案
sys.path
学生答案
Path

4.Python   内置函数__用来打开或创建文件并返回文件对象。
正确答案
openO
学生答案
epen

5.已知当前文件夹中有纯英文文本文件readme.txt, 请填空完成功能把readme.txt文件中的所有内容复制到dst.txt中 ，with open(readme.txt)as     src,open('dst.txt,_)as      dst:dst.write(src.readO)。
正确答案
'w'
6.Python 标准库os 中用来创建文件夹的函数是__,如果要创建的文件夹已存在会报错抛出异常。
正确答案
mkdirO
学生答案
mkdir

7.带有else的异常处理结构，如果try中的代码抛出了异常，那么else中的代码将_ (会、不会?)执行。
正确答案
不会
学生答案
不会

8.在try…except…异常处理结构中，     用于尝试捕捉可能出现的异常。
正确答案
except
学生答案
except

9.Python 标准库__可以用来创建GU 应用程序。
正确答案
tkinter
学生答案
tkinter

10.tkinter应用程序的    方法用来启动消息主循环和应用程序。
正确答案
mainloop0
 

11.通过request模块爬取“新浪新闻国内新闻”的源码
import requests
res    =requests.get(http://news.sina.com.cn/china/)
res,encoding=utf-8'#         修改编码方式为utf-8,  可以识别汉字       #输出源码
正确答案
print(res.text)
学生答案
无

13 .使用select找出含有 “h1”  标签的元素
soup   =BeautifulSoup(html_sample,"html.parser)
header   =soup.select('h¹)
print(header)
print(header[0]  )  输出：[<h1  id="title">Hello  World</h1>]
<h1  id="title">Hello  World</h1>
Hello  World
正确答案
print(header[0].text)
 

1.定义一个圆柱体类Cylinder, 包含底面半径和高两个属性(数据成员);包含一个可以计算圆柱体体积的方法。然后编写相关程 序测试相关功能。
正确答案
class  Cylinder:
ue(m)f(=)3.1_4init_(self,a,b):
self.r=a
 
def

def
 

self.h=b
volume(self):
r=float(self.r)
h=float(self.h)
self.v=r*r*h*Cylinder.num
print(self):
 

#主函数
a=input(“请输入圆柱体的半径：”)
b=input("请输入圆柱体的高：")
c1=Cylinder(a,b)
c1.volume()
print("  园柱体的体积为：")
c1.print()

1.设计一个Circle  ( 圆 ) 类
设计一个Circle  (圆)类，包括圆心位置、半径、颜色等属性。编写构造方法和其他方法，计算周长和面积。请编写程序验证类的功 能。
挚入示例：
J  十  乙下    例   ；
62.800000000000004314.0
正确答案
class Circle:

 
def

def

def

circle
 

_init__(self,tup,radius,color):
self.center        =tup

self.radius         =radius

self.color         =color
perimeter(self):

return                 3.14*2*self.radius

area(self):

return          3.14*self.radius          *self.radius

=Circle((0,0),10,"red")
 

print(circle.perimeter())
print(circle.area())
 

2.设计一个简单的某应用程序的用户注册窗口，填写注册姓名、性别、爱好信息，单击“提交”按钮，将出现消息对话框显示填写 的信息，如图7-41所示，根据图7-41建立应用程序界面。
正确答案
from  tkinter  import
from tkinter import messagebox as msgbox
#标签名
fields  = [姓名’,性别，爱好]
entries  =[]
def fetch(:          #提交按钮事件处理函数
content=""
for entry in entries:
field   =entry[0]        #获取标签文字
text =entry[l].get0  #获取控件中输入的内容
m='%s:%s'%(field,text)
content=content+m+"\n'
msgbox.showinfo(“注册信息”,content)

def makeform(root,fields):  #生成界面
global entries
for field in fields:
row  =Frame(root)
lab        =Label(row,width=15,text=field,anchor='w)
ent   =Entry(row)                    #产生Entry控件
rowpack(side=TOP   fill=X,padx=5,pady=5)
lab.pack(side=LEFT)
entpack(side=RIGHT,expand=YES,fill=X)
entries.append(field ,ent))#将Entry控件及对应标签文字以元组加入到entries列表中
return entries

if_name_=='_main_:
root   =Tk⁰
root.title(Message)
ents   =makeform(root,fields)
b1    =Button(root,text=”提交，command=fetch)
b¹.packside=LEFT,padx=45,pady=5)
b2     =Button(root,text=退 出 ，command=root.destroy)# 或者command=quit
b2,pack(side=RIGHT,padx=45,pady=5)
root.mainloop0
 

(   )不是用于处理中文的字符编码。
Ascii
(   )可以返回x的整数部分
math.trunc(x)
关于列表数据结构，下面描述正确的是
可以不按顺序查找元素
字符串函数strip()的作用是什么？
去掉字符串两侧空格或指定字符
"abc"的长度是3，"老师好"的长度是多少？
3
字符串是一个连续的字符序列，用什么方式打印出可以换行的字符串？
使用\n
下列哪项类型数据是不可变化的：
元组
对于字典d={'abc':1, 'qwe':2, 'zxc':3}，len(d)的结果为：
3
以下关于列表表述中错误的是哪一项？
列表与字符串一样都是不可变的。
以下关于Python的说法中正确的是哪一项？
可以在函数参数名前面加上星号*，这样用户所有传来的参数都被收集起来然后使用，星号在这里的作用是收集其余的位置参数，这样就实现了变长参数。
以下关于Python自带数据结构的运算结果中错误的是哪一项？
l = [1, 2, 3, 4]; l.insert(2, -1); 则l为 [1, 2, -1, 4]。
以下关于Python自带数据结构的运算结果中正确的是哪一项？
l = [2, 1, 3, 5, 4]; l.remove(3); l.sort(); 则运算之后l为[1, 2, 4, 5]
以下关于Python自带数据结构的运算结果中正确的是哪一项？
scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; sorted(scores.keys())的运算结果是 ['Bill', 'Jack', 'Jay', 'Mike']
以下描述中错误的是哪一项？
在遍历列表的同时可以修改列表本身，例如如下的代码可以做到。 words = ['I', 'love', 'Python']   for w in words:     if len(w) > 4:         words.insert(0, w)
对于一个列表aList和一个元组bTuple，以下函数调用错误的选项是哪一个？
bTuple.sort()
（ ）函数以一系列列表作为参数，将列表中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
zip
关于列表数据结构，下面描述正确的是（ )。
可以不按顺序查找元素
以下哪条语句定义了一个Python字典（ ）。
{1:2,2:3 }
以下关于Python自带数据结构的运算结果中错误的是哪一项？
l =
算法是指（）
解决问题的精确步骤
在遍历列表的同时可以修改列表本身，例如如下的代码可以做到。  words = ['I', 'love', 'Python']    for w in words:      if len(w) > 4:          words.insert(0, w)
Python语言有哪些特点和缺点？
Python支持命令式编程、函数式编程，完全支持面向对象程序设计，语法简洁清晰，并且拥有大量的几乎支持所有领域应用开发的成熟扩展库。 Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容。用Python开发，许多功能不必从零编写，直接使用现成的即可。除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你开发的代码通过很好的封装，也可以作为第三方库给别人使用。 Python同时也支持伪编译将Python源程序转换为字节码来优化程序和提高运行速度，可以在没有安装Python解释器和相关依赖包的平台上运行。 任何编程语言都有缺点，Python缺点主要有： （1）运行速度慢。 （2）代码不能加密。 （3）用缩进来区分语句关系的方式还是给很多初学者带来了困惑。最常见的情况是tab和空格的混用会导致错误。
Python基本输入输出函数是什么？
用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为： x=input('提示：') 该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。 Python 3.7中使用print()函数进行输出。
如何在IDLE中运行和调试Python程序？
在“Python Shell”窗口中单击“Debug”菜单中的“Debugger”菜单项，就可以启动IDLE的交互式调试器。这时，IDLE会打开的“Debug Control”窗口，并在“Python Shell”窗口中输出“[DEBUG ON]”并后跟一个“>>>”提示符。这样，我们就能像平时那样使用这个“Python Shell”窗口了，只不过现在输入的任何命令都是允许在调试器下。 我们可以在“Debug Control”窗口查看局部变量和全局变量等有关内容。
为什么要在程序中加入注释？怎么在程序中加入注释？ 一个好的、可读性强的程序一般包含20%以上的注释。
方法一：以#开始，表示本行#之后的内容为注释。 #循环输出0到9数字 for i in range(10): print (i, end=' ') 方法二：包含在一对三引号'''...'''或"""..."""之间且不属于任何语句的内容将被解释器认为是注释。
把下列数学表达式转换成等价的Python表达式。
(-b+（b*b-4*a*c)**(1/2))/(2*a) 、(x*x+y*y)/(2*a*a) 、(x+y+z)/((x**3+y**3+z**3)**(1/2)) 、((3+a)**2)/(2*c+4*d) 、2*sin((x+y)/2)*cos((x-y)/2)
数学上3<x<10 表示成正确的Python表达式为___
（x>3）and（x<10）
以3为实部4为虚部，Python复数的表达形式为___
3+4j
假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[3:7]得到的值是___
[6,7,9,11]
语句[5 for i in range(10)]执行结果为___
[5,5,5,5,5,5,5,5,5,5]
Python内置函数___可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。
len()
计算下列表达式的值（可在上机时验证），设a=7,b=-2,c=4。 （1）3 * 4 ** 5 / 2：___ （2）a * 3 % 2：___ （3）a%3 +b*b- c//5：___ （4）b**2-4*a*c：___
1536.0 、1 、5 、-108
Python数据类型有哪些？分别什么用途？
Python 数值类型用于存储数值。整型(int) ：通常被称为是整型或整数，是正或负整数，不带小数点。长整型(long) ：无限大小的整数，整数最后是一个大写或小写的L。在Python3里，只有一种整数类型 int，没有Python2 中的 Long。浮点型(float)：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.78e2就是2.78 x 102 = 278）复数(complex)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的虚部以字母j或J结尾。如：2+3j。
求列表s=[9，7，8，3，2，1，55，6]中的元素个数，最大数，最小数？如何在列表s中添加一个元素10？如何从列表s中删除一个元素55？
s=[9，7，8，3，2，1，55，6]
len(s)
max(s)
min(s)
s.append(10)
print(s)
s.remove(55)
print(s)
元组与列表主要区别？s=（9，7，8，3，2，1，55，6）能添加元素吗？
元组不能添加元素，列表可以添加元素。所以s.元组不能添加元素。
“百马百瓦问题”：有100匹马驮100块瓦，大马驮3块，小马驮2块，两个马驹驮1块。问大马、小马、马驹各有多少匹？
for i in range(34):
    for j in range(51):
        k=100-i-j
        if 3*i+2*j+k/2==100 and k%2==0:
            print("大马有：",i,"小马有： ",j,"马驹有： ",k)
有一个数列，其前三项分别为1、2、3，从第四项开始，每项均为其相邻的前三项之和的1/2，问：该数列从第几项开始，其数值超过1200。
a=[0 for x in range(0, 100)]
a[0]=1
a[1]=2
a[2]=3
i=3
while 1:
a[i]=(a[i-1]+a[i-2]+a[i-3])/2
if a[i]>1200:
print(i+1)
break
找出1与100之间的全部“同构数”。“同构数”是这样一种数，它出现在它的平方数的右端。例如，5的平方是25，5是25中右端的数，5就是同构数，25也是一个同构数，它的平方是625。
for i in range(1,101):
    k=i*i
    if i<10:
        if k%10==i:
            print(i)
    elif i<100:
        if k%100==i:
            print(i)
    else:
        if k%1000==i:
            print(i)
猴子吃桃问题。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个，第二天早上将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃前一天剩下的一半再加一个。到第10天早上想再吃时，发现只剩下一个桃子了。求第一天共摘了多少个桃子。
程序分析：采取逆向思维的方法，从后往前推断。 
程序源代码： 
x2 = 1
for day in range(9,0,-1):
    x1 = (x2 + 1) * 2
    x2 = x1
print (x1)
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。
for j in range(2,1001):
    k = []
    n = -1
    s = j
    for i in range(1,j):
         if j % i == 0:
             n += 1
             s -= i
             k.append(i)

    if s == 0:  #是完数
        print (j)
        for i in range(n):
            print(k[i],end=' ')
        print(k[n])
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
import math
def IsPrime(Num):
    if Num ==1:
        return False
    for i in range(2,int(math.sqrt(Num))+1):
        if Num%i==0:
            return False
    return True

oList = []
for i in range(100,999+1):
    if IsPrime(i)==True:
        oList.append(i)
print(oList)
编写一个函数，求满足以下条件的最大的n值： 12+22+32+42+…+n2<1000
def s():
   sum=0
   n=0
   while sum<1000:
      n=n+1
      sum=sum+n*n

   return n-1
print(s())
反序输出输入的5个字符。
def revser(s):
   return s[::-1]
print(revser("abcde"))
编写一递归函数将所输入的5个字符按相反的顺序排列出来。（递归）
def shuru(n):
   if n==0:
      return 
   c=input()  #仅输入1个字符
   shuru(n-1)
   print(c)
shuru(5)
编写一个函数multi()，参数个数不限，返回所有参数的乘积。
def multi(*num):
   sum=1    
   for i in num :       
      sum=sum*i     
   return sum
print(multi(2,3,4))
编写一个函数，功能是求两个正整数m和n的最大公约数。
def gcd(m, n):
   if m < n:
      m, n = n, m 
   while n != 0:
      temp = m % n
      m = n
      n = temp
   return m
print(gcd(24,36)) 
求一元二次方程ax2+bx+c=0的根，用3个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
import math
def m(a,b,c):
   delta = b ** 2 - 4 * a *c
   root = math.sqrt(delta)
   s1 = (-b + root) / (2 * a)
   s2 = (-b - root) / (2 * a)
   print('实根为:', s1, s2)
def n(a,b,c):
   delta = (b ** 2 - 4 * a *c)*(-1)
   root = complex(0,math.sqrt(delta))
   s1 = (-b + root) / (2 * a)
   s2 = (-b - root) / (2 * a)
   print('虚根为', s1, s2) 
编写一个函数，求方程ax2+bx+c=0的根，用1个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
import math
def solve(a,b,c):
    if a == 0:
        return –c/b;
    else:
        if b*b-4*a*c < 0:
            x1=complex((-b)/(2*a),math.sqrt(abs((b*b-4*a*c))))
            x2=complex((-b)/(2*a),-math.sqrt(abs((b*b-4*a*c))))
        elif b*b-4*a*c == 0:
            x1=(-b)/(2*a)
            x2=(-b)/(2*a)
        elif b*b-4*a*c > 0:
            x1=(-b+math.sqrt(b*b-4*a*c))/(2*a)
            x2=(-b-math.sqrt(b*b-4*a*c))/(2*a)
return (x1,x2)
x = int(input("请输入a:"))
y = int(input("请输入b:"))
z = int(input("请输入c:"))
print("求解：",solve(x,y,z))
编写一个函数，调用该函数能够打印一个由指定字符组成的n行金字塔。其中，指定打印的字符和行数n分别由两个形参表示。
def jinzita(n):
    for i in range(1,n): #[1,2,3,4,...n-1]
        print(''*(20-(i-1))+'*'*(2*i-1))
#主程序
a= int (input("输入打印行数："))
jinzita(a+1)
编写一个判断n是完数的函数，
def judge(n):
    sum=0
    for i in range(1,n):
        if n%i == 0:
            sum += i
    if sum == n:
        print(n,"是完数！")
    else:
        print(n,"不是完数！") 
def judge(n):
    sum=0
    for i in range(1,n):
        if n%i == 0:
            sum += i
    if sum == n:
        print(n,"是完数！")
    else:
        print(n,"不是完数！")
n=input("")
judge(n) 
def judge(n):
    sum=0
    for i in range(1,n):
        if n%i == 0:
            sum += i
    if sum == n:
        print(n,"是完数！")
    else:
        print(n,"不是完数！")
n=int(input("请输入n的值：")）
judge(n)
十进制转二进制
def binary(n):
    list = []
    while n//2 != 0:
        list.append(n%2)
        n = n // 2
        if n//2 == 0:
            list.append(n%2)
            break
    list.reverse()
    for t in list:
        print(t,end='')
    print()
实现回文字符串
def huiwen(e):
    x=0
    y=len(e)-1
while x<y:
if(e[x] != e[y]):
break
        x+=1
y-=1
if(x<y):
flag=0
else:
flag=1
return flag
e=input("请输入一串字符\n")
if(huiwen(e)):
    print("这是回文字符串\n")
else:
print("这不是回文字符串\n") 
统计字符串中有多少个单词
def geshu(e):
    a=e.split(' ')
return len(a)
e=input("请输入一句话\n")
print("这句话中有%d个单词"%geshu(e))
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
import math
def IsPrime(Num):
    if Num ==1:
        return False
    for i in range(2,int(math.sqrt(Num))+1):
        if Num%i==0:
            return False
    return True

oList = []
for i in range(100,999+1):
    if IsPrime(i)==True:
        oList.append(i)
print(oList) 
编写程序，打开任意的文本文件，读出其中内容，判断该文件中某些给定关键字如“中国”出现的次数。
n=0
#hellofile=open("d:\\152\\612.txt")
filename = input("please input filename")
hellofile=open("d:\\152\\"+filename)
filecontent=hellofile.readlines()
hellofile.close()

print(filecontent)  #['中国\n', '美国\n', '中国人民\n', '日本\n', '中国人']

for s in filecontent:
    n=n+s.count("中国")            
print(n)
编写程序，打开任意的文本文件，在指定的位置产生一个相同文件的副本，即实现文件的拷贝功能。
def copy_file(oldfile,newfile):
    oldFile=open(oldfile,"r")
    newFile=open(newfile,"w")
    while True:
        filecontent=oldFile.read(50)
        if  filecontent=="":
            break
        newFile.write(filecontent)
    oldFile.close()
    newFile.close()
    return
用Windows“记事本”创建一个文本文件，其中每行包含一段英文。试读出文件的全部内容，并判断： （1）该文本文件共有多少行？ （2）文件中以大写字母P开头的有多少行？ （3）一行中包含字符最多的和包含字符最少的分别在第几行？
（1）
file1=open("d:\\152\\test.txt")
filecontent=file1.readlines()   #列表
file1.close()
a=len(filecontent)
print(a)

（2）
>>> s="pig"
>>> s.startswith('p')
True
>>> s="hello"
>>> s.startswith('p')
False

file1=open("d:\\test.txt")
filecontent=file1.readlines()   #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=0
for s in filecontent:
    if s.startswith('P')==True:
        print(s)
        n+=1
print("以大写字母P开头的有",n,"行")
  （3）
file1=open("d:\\test.txt")
filecontent=file1.readlines()   #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=1
maxnum=0

for s in filecontent:
    k=len(s)
    if k>maxnum:
        maxnum=k
        pos=n
    n+=1    

print("一行中包含字符最多的是",pos,"行")
print("一行字符最多的是",maxnum)
定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；包含一个可以计算圆柱体体积的方法。然后编写相关程序测试相关功能。
class Cylinder:
    num=3.14
    def __init__(self,a,b):
        self.r=a
        self.h=b
    def volume(self):
        r=float(self.r)
        h=float(self.h)
        self.v=r*r*h*Cylinder.num
    def print(self):
        print(self.v)
#主函数
a=input("请输入圆柱体的半径:")
b=input("请输入圆柱体的高:")
c1=Cylinder(a,b)
c1.volume()
print("圆柱体的体积为:")
c1.print() 
定义一个学生类，包括学号、姓名和出生日期三个属性（数据成员）；包括一个用于给定数据成员初始值的构造函数；包含一个可计算学生年龄的方法。编写该类并对其进行测试。
class Student:
    def __init__(self,a,b,c):
        self.number=a
        self.name=b
        self.birthday=c
    def Age(self):
        self.age=2017-int(self.birthday[0:4])
    def print(self):
        print("学生的学号为:",self.number)
        print("学生的名字为:",self.name)
        print("学生的生日为:",self.birthday)
        print("学生的年龄为:",self.age)
#主函数
a,b,c=input("请输入学生的学号、名字以及生日(空格隔开):").split(' ')
s1=Student(a,b,c)
s1.Age()
s1.print()
设计一个程序，用两个文本框输入数值数据，用列表框存放“＋、－、×、÷、幂次方、余数”。用户先输入两个操作数，再从列表框中选择一种运算，即可在标签中显示出计算结果。 实现简单加减乘除程序。使用两个单行文本框输入数字，使用列表框选择运算。
from tkinter import *
import tkinter as tk
root = Tk()
m = StringVar()
def callbutton2():
    a=float(num1.get())        #获取第1个数
    b=float(num2.get())        #获取第2个数
    print(lb.curselection())
    k=lb.get(lb.curselection())    #获取选中的运算符
    print(k)
    if k=='加':
        print(a+b)
        result["text"]=str(a+b)
        #result.config(text=str(a+b))
    if k=='减':
        print(a-b)
        result["text"]=str(a-b)
    if k=='乘':
        print(a*b)   
        result["text"]=str(a*b)
    if k=='除':
        print(a/b)   
        result["text"]=str(a/b)
root.title("使用Listbox组件的例子")        #设置窗口标题
lab1=Label(root,text = '请输入第1个数',width=20)
lab1.pack()
num1 = tk.Entry(root)                    #Entry组件
num1.pack()
lab2=Label(root,text = '请输入第2个数',width=20)
lab2.pack()
num2 = tk.Entry(root)                    #Entry组件
num2.pack()
lb = Listbox(root, listvariable =m)            #将一字符串与Listbox的值绑定
lb.insert(END,'加')
lb.insert(END,'减')
lb.insert(END,'乘')
lb.insert(END,'除')
lb.pack()
b2 = Button (root,text = '计算', command=callbutton2, width=20)#创建Button组件
b2.pack()                            #显示Button组件
result=Label(root,text = '结果',width=6)
result.pack()
root.mainloop()
编写选课程序。左侧列表框显示学生可以选择的课程名，右侧列表框显示学生已经选择的课程名，通过4个按钮在两个列表框中移动数据项。通过“〉”、“〈”按钮移动一门课程，通过“》”、“《”按钮移动全部课程。程序运行界面见图7-42所示。
from tkinter import *          
root = Tk()                     
def callbutton1():  #>选中一门
    for i in listb.curselection():  
        listb2.insert(0,listb.get(i))
        listb.delete(i)
def callbutton2():  #<取消一门
    for i in listb2.curselection():
        listb.insert(0,listb2.get(i))
        listb2.delete(i)
def callbutton3():  #>>全部选中
    for i in range(0,listb.size()):
        listb2.insert(0,listb.get(i))
    for i in range(listb.size()-1,-1,-1):
        listb.delete(i)
def callbutton4():  #>>全部取消
    for i in range(0,listb2.size()):
        listb.insert(0,listb2.get(i))
    for i in range(listb2.size()-1,-1,-1):
        listb2.delete(i)        
li = ['Flash动画设计','数据库原理','大数据应用','Java程序设计','C#程序设计','网站开发','计算机导论','数据结构']
listb = Listbox(root)  #左边列表框          
listb2 = Listbox(root) #右边列表框
for item in li:                   
    listb.insert(0,item)
listb.grid(row=0,column=0,rowspan=4)                     
b1 = Button (root,text = '>', command=callbutton1, width=20)
b2 = Button (root,text = '>>', command=callbutton3, width=20)
b3 = Button (root,text = '<', command=callbutton2, width=20)
b4 = Button (root,text = '<<', command=callbutton4, width=20)
b1.grid(row=0,column=1)                       
b2.grid(row=1,column=1)
b3.grid(row=2,column=1)
b4.grid(row=3,column=1)                      
listb2.grid(row=0,column=2,rowspan=4)
root.title("选课程序")        #设置窗口标题
root.mainloop()
题目：创建一个数据库stuinfo，并在其中创建数据库表student，表中包含stuid(学号)、stuname（姓名）、birthday（出生日期）、sex（性别）、address（家庭地址）、rxrq（入学日期）6列，其中stuid设为主键，并添加5条记录。 将所有记录的rxrq属性更新为2017-9-1。 查询性别为“女”的所有学生的stuname和address字段值。
import sqlite3
con=sqlite3.connect("sales.db")
cur=con.cursor()
cur.execute("DROP table book")#第一次运行时这句删掉，之后再运行加上。
con.execute("create table book(stuid primary key,stuname varchar(20),birthday integer(20),sex varchar(20),address varchar(20),rxrq integer(20))")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (1,'张一',19980301,'男','黄河路1号',20160901)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (2,'张二',19980302,'女','黄河路2号',20160902)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (3,'张三',19980303,'男','黄河路3号',20160903)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (4,'张四',19980304,'男','黄河路4号',20160904)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (5,'张五',19980305,'女','黄河路5号',20160905)")
print('记录计入完成')
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('记录更新完成')
cur.execute("Update book set rxrq=20170901")
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('性别为女的名字和地址信息为：')
cur.execute('select stuname,sex,address from book')
values = cur.fetchall()
for row in values:
    if row[1]=='女':
print(row[0],row[2])
cur.close()
con.commit()
con.close()
TCP协议和UDP协议的主要区别是什么？
TCP协议建立在IP协议之上，负责在两台计算机之间建立可靠连接，保证数据包按顺序到达。TCP协议会通过握手建立连接，然后，对每个IP包编号，确保对方按顺序收到。如果包丢掉了，就自动重发。 UDP协议也建立在IP协议之上，但是UDP协议是面向无连接的通信协议，不保证数据包的顺利到达，不可靠传输。所以效率比TCP要高。 使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。虽然用UDP传输数据不可靠，但它的优点是和TCP相比，速度快，对于不要求可靠到达的数据，就可以使用UDP协议。
Socket有什么用途？
socket 用来写网络通讯程序的，简单来说在远程机器（服务器）和本地机器各建一个socket，然后即可进行连接通讯。 Socket非常类似于电话插座。以一个国家级电话网为例，电话的通话双方相当于相互通信的2个进程，区号是它的网络地址;分配给每个用户的电话号码相当于Socket号。任何用户在通话之前，首先要占有一部电话机，相当于申请一个Socket;同时要知道对方的号码，相当于对方有一个固定的Socket。然后向对方拨号呼叫，相当于发出连接请求(假如对方不在同一区内，还要拨对方区号，相当于给出网络地址)。假如对方在场并空闲(相当于通信的另一主机开机且可以接受连接请求)，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向Socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭Socket，撤消连接。
简单描述开发UDP程序的过程。
python udp是无连接，没有TCP的三次握手，错误重传机制，发的只管发，收的只管收，效率比TCP高，运用于对数据帧不高的地方，如视频，音频的传输。 一、实现过程: 服务器端过程如下: 1.建立UDP的SOCKET 2.绑定一个接口，让客户端连接 3.接受数据 客户端过程如下: 1.创建一个socket 2.收发数据报 二、代码实现 1.服务器端： import socket from time import ctime def udpServer(): buffer=2048 address=('127.0.0.1',8080) udpsock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) udpsock.bind(address) while True: #不断循环 print ('wait for message...') data,addr=udpsock.recvfrom(buffer) #接受数据 str='[%s]%s' %(ctime(),data.decode('utf-8')) udpsock.sendto(str.encode('utf-8'),addr) #发送数据 print ('...received from and retuned to:',addr) udpsock.close() if __name__=='__main__': udpServer() 2.客户端: import socket def udpClient(): address=('localhost',8080) udpClientSocket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #创建socket while True: #不断循环 data= input('>') if not data: break udpClientSocket.sendto(data.encode('utf-8'),address) #发送数据 data,addr=udpClientSocket.recvfrom(2048) print (data.decode('utf-8')) udpClientSocket.close() if __name__=='__main__': udpClient() 运行结果： 服务器端： wait for message... ...received from and retuned to: ('127.0.0.1', 61957) wait for message... ...received from and retuned to: ('127.0.0.1', 61957) wait for message... 客户端: >中国 [Sat Mar 24 10:35:19 2018]中国 >hello [Sat Mar 24 10:35:29 2018]hello >
编写获取本机IP的程序。
import socket
myname = socket.getfqdn(socket.gethostname( ))#获取本机电脑名
myaddr = socket.gethostbyname(myname)#获取本机ip
print(myname,myaddr)

import uuid
#python 获得本机MAC地址：
def get_mac_address(): 
mac=uuid.UUID(int = uuid.getnode()).hex[-12:] 
return ":".join([mac[e:e+2] for e in range(0,11,2)])
print("本机MAC地址:",get_mac_address())
用Python绘制余弦
import numpy as np import scipy as sp import pylab as pl x=np.linspace(0,4*np.pi,100) pl.plot(x,pl.cos(2*x)) pl.show()
用Python画一个笛卡尔心形线
import numpy as np
import matplotlib.pyplot as plt
a = 1
t = np.linspace(0, 2*np.pi, 1024)
X = a*(2*np.cos(t) - np.cos(2*t))/2
Y = a*(2*np.sin(t) - np.sin(2*t))
plt.plot(Y, X, c = 'r')
plt.show()
<img src="https://cdn1.qingline.net/2bff4988adc793cba56c8c65b42ee723.png" />
编程实现图像手绘效果
from PIL import Image
import numpy as np 
a = np.asarray(Image.open(r"小张.jpg").convert('L')).astype('float')

depth = 10.                      # (0-100)
grad = np.gradient(a)             #取图像灰度的梯度值
grad_x, grad_y =grad         #分别取横纵图像梯度值
grad_x = grad_x*depth/100.       #列梯度值*0.1
grad_y = grad_y*depth/100.

A = np.sqrt(grad_x**2 + grad_y**2 + 1.)  #相当于grad_z=1
uni_x = grad_x/A
uni_y = grad_y/A
uni_z = 1./A          #梯度归一化

vec_el = np.pi/2.2# 光源的俯视角度，弧度值
vec_az = np.pi/4.                    # 光源的方位角度，弧度值
dx = np.cos(vec_el)*np.cos(vec_az)   #光源对x 轴的影响
dy = np.cos(vec_el)*np.sin(vec_az)   #光源对y 轴的影响
dz = np.sin(vec_el)              #光源对z 轴的影响

b = 255*(dx*uni_x + dy*uni_y + dz*uni_z)     #光源归一化
b = b.clip(0,255) 
im = Image.fromarray(b.astype('uint8'))    #重构图像
im.save(r"img_1.jpg")

第1-2章作业2
总分：100分
得分：91.0分
+ 2.0 分
1 . 单选题 简单 2分
关于赋值语句的作用，正确的描述是
A.
变量和对象必须类型相同
B.
每个赋值语句只能给一个变量赋值
C.
将变量改写为新的值
D.
将变量绑定到对象
 回答正确
正确答案
D
解析

+ 2.0 分
2 . 单选题 简单 2分
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是
A.
a[0] = 'e'
B.
replace('a', 'e')
C.
a[1] = 'e'
D.
a = 'e' + a[1:]
 回答正确

D
正确答案
D
解析

+ 2.0 分
3 . 单选题 简单 2分
下列不合法的Python变量名是
A.
Python2
B.
N.x
C.
sum
D.
Hello_World
 回答正确

B
正确答案
B
解析

+ 2.0 分
4 . 单选题 简单 2分
执行以下两条语句后，lst的结果是 1. lst = [3, 2, 1] 2. lst.append(lst)
A.
[3, 2, 1, [3, 2, 1]]
B.
[3, 2, 1, […]]，其中“…”表示无穷递归
C.
抛出异常
D.
[3, 2, 1, lst]
 回答正确

B
正确答案
B
解析

+ 2.0 分
5 . 单选题 简单 2分
下列不是Python语言关键字的是
A.
open
B.
if
C.
lambda
D.
finally
 回答正确

A
正确答案
A
解析

+ 2.0 分
6 . 单选题 简单 2分
与x > y and y > z 语句等价的是
A.
x > y > z
B.
not x < y or not y < z
C.
not x < y or y < z
D.
x > y or not y < z
 回答正确

A
正确答案
A
解析

+ 2.0 分
7 . 单选题 简单 2分
以下哪条语句定义了一个Python字典
A.
{ }
B.
{1, 2, 3}
C.
[1, 2, 3]
D.
(1, 2, 3)
 回答正确

A
正确答案
A
解析

+ 2.0 分
8 . 单选题 简单 2分
执行下面操作后，list2的值是： 1. list1 = ['a', 'b', 'c'] 2. list2 = list1 3. list1.append('de')
A.
['a', 'b', 'c']
B.
['a', 'b', 'c', 'de']
C.
['d', 'e', 'a', 'b', 'c']
D.
['a', 'b', 'c', 'd', 'e']
 回答正确

B
正确答案
B
解析

+ 2.0 分
9 . 单选题 简单 2分
下列运算符的使用错误的是：
A.
1 + 'a'
B.
[1, 2, 3] + [4, 5, 6]
C.
3 * 'abc'
D.
-10 % -3
 回答正确

A
正确答案
A
解析

+ 2.0 分
10 . 单选题 简单 2分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.
s[3]
B.
s[-3]
C.
s[0:-3]
D.
s[:-3]
 回答正确

B
正确答案
B
解析

+ 2.0 分
11 . 单选题 简单 2分
获得字符串s长度的方法是什么？
A.
s.len()
B.
s.length
C.
len(s)
D.
length(s)
 回答正确

C
正确答案
C
解析

+ 2.0 分
12 . 单选题 简单 2分
Python中布尔变量的值为
A.
真，假
B.
0,1
C.
T,F
D.
True，False
 回答正确

D
正确答案
D
解析

+ 2.0 分
13 . 单选题 简单 2分
对负数取平方根，即使用函数math.sqrt(x)，其中x为负数，将产生
A.
什么都不产生
B.
虚数
C.
程序崩溃
D.
ValueError错误
 回答正确

D
正确答案
D
解析

+ 2.0 分
14 . 单选题 简单 2分
下列哪一项不是Python的数据类型：
A.
string
B.
float
C.
rational
D.
int
 回答正确

C
正确答案
C
解析

+ 2.0 分
15 . 单选题 简单 2分
下面哪一个不是Python语言的合法命名：
A.
monthly
B.
_Monthly3_
C.
monTHly
D.
3monthly
 回答正确

D
正确答案
D
解析

+ 2.0 分
16 . 单选题 简单 2分
Python中，用于获取用户输入的命令为：
A.
input
B.
read
C.
get
D.
for
 回答正确

A
正确答案
A
解析

+ 2.0 分
17 . 单选题 简单 2分
用于生成和计算出新的数值的一段代码称为：
A.
表达式
B.
赋值语句
C.
生成语句
D.
标识符
 回答正确

A
正确答案
A
解析

+ 2.0 分
18 . 单选题 简单 2分
以下关于Python数值运算描述错误的是哪一项？
A.
Python支持+=、%=这样的增量赋值操作符。
B.
在Python 2.x中，默认情况下10/3 == 3的判别结果是False，而Python 3.x中则不同。
C.
Python内置支持复数运算，可以使用j或者J来表示。
D.
%运算符表示运算对象取余。
 回答正确

B
正确答案
B
解析

+ 2.0 分
19 . 单选题 简单 2分
以下关于字符串处理的描述错误的是哪一项？
A.
print （'C:\file\time'），输出结果是C:\file\time。
B.
Python 2.x中字符串是以单引号或双引号括起来的任意文本，如果字符串赋值的时候，内部有单引号或双引号时如果不想使用转义字符常常可以使用r运算符来表示。
C.
"\"符号可以被用来表示转义符号，例如'doesn\'t'和"doesn't"都表示字符串doesn't。
D.
被单引号('...')或者双引号("...")包围的都是字符串。
 回答正确

A
正确答案
A
解析

+ 2.0 分
20 . 单选题 简单 2分
以下关于字符串处理正确的是哪一项？
A.
字符串是自带索引的，对变量word = "Python"，word
B.
+号可以用来拼接两个字符串，对于以下代码的输出字符串是Python 1. >>> prefix = "Py" 2. >>> prefix + 'thon'
C.
字符串的索引有两个边界，前边界和后边界都是包括的。
D.
对于字符串"apple"， 3 * "apple"的结果为"3apple"。
 回答正确

B
正确答案
B
解析

+ 2.0 分
21 . 单选题 简单 2分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.
s[3]
B.
s[-3]
C.
s[0:-3]
D.
s[:-3]
 回答正确

B
正确答案
B
解析

+ 2.0 分
22 . 单选题 简单 2分
关于赋值语句的作用，正确的描述是（ )。
A.
将变量绑定到对象
B.
每个赋值语句只能给一个变量赋值
C.
将变量改写为新的值
D.
变量和对象必须类型相同
 回答正确

A
正确答案
A
解析

+ 2.0 分
23 . 单选题 简单 2分
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是（ )。
A.
a[0] = 'e'
B.
replace('a', 'e')
C.
a[1] = 'e'
D.
a = 'e' + a[1:]
 回答正确

D
正确答案
D
解析

+ 2.0 分
24 . 单选题 简单 2分
下列不合法的Python变量名是（ )。
A.
Python2
B.
N_x
C.
sum
D.
Hello$World
 回答正确

D
正确答案
D
解析

+ 2.0 分
25 . 单选题 简单 2分
下列不是Python语言关键字的是（ ）。
A.
else
B.
print
C.
lambda
D.
finally
 回答正确

A
正确答案
A
解析

+ 2.0 分
26 . 单选题 简单 2分
下列运算符的使用错误的是（ ）。
A.
1 + 'a'
B.
[1, 2, 3] + [4, 5, 6]
C.
3 * 'abc'
D.
-10 % -3
 回答正确

A
正确答案
A
解析

+ 2.0 分
27 . 单选题 简单 2分
用于生成和计算出新的数值的一段代码称为：
A.
赋值语句
B.
表达式
C.
生成语句
D.
标识符
 回答正确

B
正确答案
B
解析

+ 2.0 分
28 . 单选题 简单 2分
以下关于Python数值运算描述错误的是哪一项？
A.
Python支持+=、%=这样的增量赋值操作符。
B.
默认情况下10/3 == 3的判别结果是True
C.
Python内置支持复数运算，可以使用j或者J来表示。
D.
%运算符表示运算对象取余。
 回答正确

B
正确答案
B
解析

+ 2.0 分
29 . 单选题 简单 2分
下列哪个语句在Python中是非法的（ ）。
A.
x = y = z = 1   
B.
x = (y = z + 1) 
C.
x, y = y, x  
D.
x  +=  y
 回答正确

B
正确答案
B
解析

+ 2.0 分
30 . 单选题 简单 2分
下面哪个不是Python合法的标识符（ ）。
A.
int32   
B.
40XL 
C.
self  
D.
__name__
 回答正确

B
正确答案
B
解析

+ 2.0 分
31 . 单选题 简单 2分
下列哪种说法是错误的（ ）。
A.
除字典类型外，所有标准对象均可以用于布尔测试 
B.
空字符串的布尔值是False 
C.
空列表对象的布尔值是False 
D.
值为0的任何数字对象的布尔值是False
 回答正确

A
正确答案
A
解析

+ 2.0 分
32 . 单选题 简单 2分
Python不支持的数据类型有（ ）。
A.
char   
B.
int    
C.
float   
D.
list
 回答正确

A
正确答案
A
解析

+ 2.0 分
33 . 单选题 简单 2分
以下不能创建一个字典的语句是 （ ）。
A.
dict1 = {}  
B.
dict2 = { 3 : 5 }    
C.
dict3 = {[1,2,3]: “uestc”}
D.
dict4 = {(1,2,3): “uestc”}
 回答正确

C
正确答案
C
解析

+ 2.0 分
34 . 单选题 简单 2分
关于字符串下列说法错误的是（ ）。
A.
字符应该视为长度为1的字符串
B.
字符串以\0标志字符串的结束
C.
既可以用单引号，也可以用双引号创建字符串
D.
在三引号字符串中可以包含换行回车等特殊字符
 回答正确

B
正确答案
B
解析

+ 2.0 分
35 . 单选题 简单 2分
下列表达式的值为True的是（ ）。
A.
(2**=3)<(2*=3) 
B.
3>2>2  
C.
1==1 and 2!=1 
D.
not(1==1 and 0!=1) 
 回答正确

C
正确答案
C
解析

+ 2.0 分
36 . 单选题 简单 2分
type(1+2L*3.14)的结果是（ ）。
A.
<class ‘int’>   
B.
<class ‘long’>  
C.
<class ‘float’> 
D.
<class ‘str’>
 回答正确

C
正确答案
C
解析

+ 0.0 分
37 . 填空题 困难 2分
把下列数学表达式转换成等价的Python表达式。 
 
___、___、___、___、___ 提示：math.sin(x)函数返回的x弧度的正弦值，math.cos(x)函数返回的x弧度的余弦值，math.sqrt(x)函数返回数字x的平方根。函数请参考第四章。
 回答错误
 无
正确答案
(-b+（b*b-4*a*c)**(1/2))/(2*a)、(x*x+y*y)/(2*a*a)、(x+y+z)/((x**3+y**3+z**3)**(1/2))、((3+a)**2)/(2*c+4*d)、2*sin((x+y)/2)*cos((x-y)/2)
解析

+ 0.0 分
38 . 填空题 困难 2分
数学上3<x<10 表示成正确的Python表达式为___
 回答错误

x ＞ 3 and x ＜ 10
正确答案
（x>3）and（x<10）
解析

+ 2.0 分
39 . 填空题 困难 2分
以3为实部4为虚部，Python复数的表达形式为___
 回答正确

3+4j
正确答案
3+4j
解析

+ 0.0 分
40 . 填空题 困难 2分
假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[3:7]得到的值是___
 回答错误

[6，7，9，11]
正确答案
[6,7,9,11]
解析

+ 0.0 分
41 . 填空题 困难 2分
语句[5 for i in range(10)]执行结果为___
 回答错误

[5，5，5，5，5，5，5，5，5，5]
正确答案
[5,5,5,5,5,5,5,5,5,5]
解析

+ 2.0 分
42 . 填空题 困难 2分
Python内置函数___可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。
 回答正确

len()
正确答案
len()
解析

+ 2.0 分
43 . 填空题 困难 2分
计算下列表达式的值（可在上机时验证），设a=7,b=-2,c=4。 （1）3 * 4 ** 5 / 2：___ （2）a * 3 % 2：___ （3）a%3 +b*b- c//5：___ （4）b**2-4*a*c：___
 回答正确

1536、1、5、-108
正确答案
1536.0、1、5、-108
解析

+ 1.0 分
44 . 简答题 困难 1分
Python数据类型有哪些？分别什么用途？
 回答正确

1. 整数（int）：用于表示整数
2. 浮点数（float）：用于表示带有小数点的数值
3. 字符串（str）：用于表示文本，在 Python 中用引号（单引号或双引号）括起来
4. 布尔值（bool）：用于表示真（True）或假（False）的值
5. 列表（list）：用于存储多个有序的元素，可以修改其中的元素顺序或添加、删除元素。
6. 元组（tuple）：类似于列表，但是不可修改，用于存储多个有序的元素。
7. 集合（set）：用于存储多个不重复的元素，支持集合的交、并、差等操作。
8. 字典（dict）：用于存储键值对（key-value），通过键访问对应的值，常用于表示映射关系。
正确答案
Python 数值类型用于存储数值。整型(int) ：通常被称为是整型或整数，是正或负整数，不带小数点。长整型(long) ：无限大小的整数，整数最后是一个大写或小写的L。在Python3里，只有一种整数类型 int，没有Python2 中的 Long。浮点型(float)：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.78e2就是2.78 x 102 = 278）复数(complex)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的虚部以字母j或J结尾。如：2+3j。
解析

+ 1.0 分
45 . 简答题 困难 1分
求列表s=[9，7，8，3，2，1，55，6]中的元素个数，最大数，最小数？如何在列表s中添加一个元素10？如何从列表s中删除一个元素55？
 回答正确

len(s) max(s) min(s)
s.append(10)
s.remove(55)
正确答案
s=[9，7，8，3，2，1，55，6] len(s) max(s) min(s) s.append(10) print(s) s.remove(55) print(s)
解析

+ 1.0 分
46 . 简答题 困难 1分
元组与列表主要区别？s=（9，7，8，3，2，1，55，6）能添加元素吗？
 回答正确

可变性：列表是可变的数据类型，可以修改其中的元素顺序、添加新元素或删除元素；而元组是不可变的数据类型，一旦创建后就不能修改其中的元素。
语法表示：列表使用方括号 [] 表示，元素之间用逗号分隔；元组使用圆括号 () 表示，元素之间也用逗号分隔。
二.不能
正确答案
元组不能添加元素，列表可以添加元素
解析

+ 1.0 分
47 . 简答题 中等 1分
Python数据类型有哪些？分别什么用途？ 
 回答正确

1. 整数（int）：用于表示整数
2. 浮点数（float）：用于表示带有小数点的数值
3. 字符串（str）：用于表示文本，在 Python 中用引号（单引号或双引号）括起来
4. 布尔值（bool）：用于表示真（True）或假（False）的值
5. 列表（list）：用于存储多个有序的元素，可以修改其中的元素顺序或添加、删除元素。
6. 元组（tuple）：类似于列表，但是不可修改，用于存储多个有序的元素。
7. 集合（set）：用于存储多个不重复的元素，支持集合的交、并、差等操作。
8. 字典（dict）：用于存储键值对（key-value），通过键访问对应的值，常用于表示映射关系。
正确答案
Python 数值类型用于存储数值。 整型(int) ：通常被称为是整型或整数，是正或负整数，不带小数点。 长整型(long) ：无限大小的整数，整数最后是一个大写或小写的L。在Python3里，只有一种整数类型 int，没有Python2 中的 Long。 浮点型(float)：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.78e2就是2.78 x 102 = 278） 复数(complex)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的虚部以字母j或J结尾。如：2+3j。
解析

+ 0.0 分
48 . 简答题 中等 1分
把下列数学表达式转换成等价的Python表达式。  提示：math.sin(x)函数返回的x弧度的正弦值，math.cos(x)函数返回的x弧度的余弦值，math.sqrt(x)函数返回数字x的平方根。函数请参考第四章。 
 回答错误
 无
正确答案
（1）（-b+（b*b-4*a*c）**（1/2））/（2*a） （2）（x*x+y*y）/（2*a*a） （3）（x+y+z）/（（x**3+y**3+z**3）**（1/2）） （4）（（3+a）**2）/（2*c+4*d） （5）2*sin（（x+y）/2）*cos（（x-y）/2）
解析

+ 1.0 分
49 . 简答题 中等 1分
数学上3
 回答正确

3
正确答案
（x>3）and（x<10）
解析

+ 1.0 分
50 . 简答题 中等 1分
以3为实部4为虚部，Python复数的表达形式为（ ） 
 回答正确

3+4j
正确答案
3+4j
解析

+ 1.0 分
51 . 简答题 中等 1分
表达式[1, 2, 3]*3的执行结果为（ ） 
 回答正确

[1，2，3，1，2，3，1，2，3]
正确答案
〔1,2,3,1,2,3,1,2,3〕
解析

+ 1.0 分
52 . 简答题 中等 1分
假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[3:7]得到的值是 （ ） 
 回答正确

[6，7，9，11]
正确答案
[ 6,7, 9, 11]
解析

+ 1.0 分
53 . 简答题 中等 1分
语句[5 for i in range(10)] 执行结果为（ ） 
 回答正确

[5，5，5，5，5，5，5，5，5，5]
正确答案
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
解析

+ 1.0 分
54 . 简答题 中等 1分
Python内置函数（ ）可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。 
 回答正确

len()
正确答案
len()
解析

+ 1.0 分
55 . 简答题 中等 1分
计算下列表达式的值（可在上机时验证），设a=7,b=-2,c=4。 （1）3 * 4 ** 5 / 2 （2）a * 3 % 2 （3）a%3 +b*b- c//5 （4）b**2-4*a*c 
 回答正确

1536 1 5 -108
正确答案
（1）1536.0 （2）1 （3）5 （4）-108
解析

+ 1.0 分
56 . 简答题 中等 1分
求列表s=[9，7，8，3，2，1，55，6]中的元素个数，最大数，最小数？如何在列表s中添加一个元素10？如何从列表s中删除一个元素55？ 
 回答正确

len(s) max(s) min(s)
s.append(10)
s.remove(55)
正确答案
s=[9，7，8，3，2，1，55，6] len(s) max(s) min(s) s.append(10) print(s) s.remove(55) print(s)
解析

+ 1.0 分
57 . 简答题 中等 1分
元祖与列表主要区别？s=（9，7，8，3，2，1，55，6）能添加元素吗？ 
 回答正确

可变性：列表是可变的数据类型，可以修改其中的元素顺序、添加新元素或删除元素；而元组是不可变的数据类型，一旦创建后就不能修改其中的元素。
语法表示：列表使用方括号 [] 表示，元素之间用逗号分隔；元组使用圆括号 () 表示，元素之间也用逗号分隔。
二.不能
正确答案
元祖不能添加元素，列表可以添加元素
解析

第1-2章作业1
1 . 单选题 简单 2分
下面不属于python特性的是（   ）。
A简单易学
B.
开源的免费的
C.
属于低级语言
D.
高可移植性
 回答正确

C
正确答案
C
解析

+ 2.0 分
2 . 单选题 简单 2分
Python脚本文件的扩展名为（   ）。
A.
.python
B.
.py
C.
.pt
D.
.pg
 回答正确

B
正确答案
B
解析

+ 2.0 分
3 . 单选题 简单 2分
下列关于程序设计语言的描述，正确的是（   ）。
A.
机器语言要通过编译才能被计算机接受
B.
早期人们使用机器语言编写计算机程序
C.
机器语言又称为高级语言
D.
现在人们普遍使用机器语言编写计算机程序
 回答正确

B
正确答案
B
解析

+ 1.0 分
4 . 简答题 困难 2分
Python语言有哪些特点和缺点？
 回答正确

简洁易读、易学易用、丰富的库、跨平台和动态类型
其缺点包括运行速度较慢、GIL的影响、执行性能问题和不适合开发底层系统。

正确答案
Python支持命令式编程、函数式编程，完全支持面向对象程序设计，语法简洁清晰，并且拥有大量的几乎支持所有领域应用开发的成熟扩展库。
Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容。用Python开发，许多功能不必从零编写，直接使用现成的即可。除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你开发的代码通过很好的封装，也可以作为第三方库给别人使用。
Python同时也支持伪编译将Python源程序转换为字节码来优化程序和提高运行速度，可以在没有安装Python解释器和相关依赖包的平台上运行。
任何编程语言都有缺点，Python缺点主要有：
（1）运行速度慢。
（2）代码不能加密。
（3）用缩进来区分语句关系的方式还是给很多初学者带来了困惑。最常见的情况是tab和空格的混用会导致错误。
解析

+ 1.0 分
5 . 简答题 困难 2分
Python基本输入输出函数是什么？
 回答正确

input  print
正确答案
用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为：
x=input('提示：')
该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。
Python 3.7中使用print()函数进行输出。
解析

+ 1.0 分
6 . 简答题 困难 2分
如何在IDLE中运行和调试Python程序？
 回答正确

运行python：从Run菜单中选择Run Module菜单项
调试：（1）直接显示程序数据；
（2）使用调试器。
正确答案
在“Python Shell”窗口中单击“Debug”菜单中的“Debugger”菜单项，就可以启动IDLE的交互式调试器。这时，IDLE会打开的“Debug Control”窗口，并在“Python Shell”窗口中输出“[DEBUG ON]”并后跟一个“>>>”提示符。这样，我们就能像平时那样使用这个“Python Shell”窗口了，只不过现在输入的任何命令都是允许在调试器下。
我们可以在“Debug Control”窗口查看局部变量和全局变量等有关内容。
解析

+ 1.0 分
7 . 简答题 困难 2分
为什么要在程序中加入注释？怎么在程序中加入注释？
一个好的、可读性强的程序一般包含20%以上的注释。
 回答正确

（1）1、标明一些基本信息。 如编写代码的作者、日期、用途、版权声明等信息。 
2、解释代码原理或用途，在程序关键代码附近增加注释，解释关键代码作用，增加程序可读性，也方便后续开发者维护代码。
3、辅助程序的调试。
（2）1、单行注释：使用”#“作为单行注释的字符，从该符号开始到换行结束；
2、多行注释：包含在一对三引号之间的内容。
     正确使用注释可以使你的代码更加清晰和有组织性。但请注意，过度注释或写下不必要的注释可能会使代码显得混乱，所以要在必要的地方恰当地添加注释。

正确答案
方法一：以#开始，表示本行#之后的内容为注释。
#循环输出0到9数字
for i in range(10):
print (i, end=' ')
方法二：包含在一对三引号'''...'''或"""..."""之间且不属于任何语句的内容将被解释器认为是注释。
解析

+ 1.0 分
8 . 简答题 中等 2分
Python语言有哪些特点和缺点？
 回答正确

简洁易读、易学易用、丰富的库、跨平台和动态类型
其缺点包括运行速度较慢、GIL的影响、执行性能问题和不适合开发底层系统。

正确答案
Python支持命令式编程、函数式编程，完全支持面向对象程序设计，语法简洁清晰，并且拥有大量的几乎支持所有领域应用开发的成熟扩展库。
Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容。用Python开发，许多功能不必从零编写，直接使用现成的即可。除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你开发的代码通过很好的封装，也可以作为第三方库给别人使用。 
Python同时也支持伪编译将Python源程序转换为字节码来优化程序和提高运行速度，可以在没有安装Python解释器和相关依赖包的平台上运行。
任何编程语言都有缺点，Python缺点主要有：
（1）运行速度慢。
（2）代码不能加密。
（3）用缩进来区分语句关系的方式还是给很多初学者带来了困惑。最常见的情况是tab和空格的混用会导致错误。
解析

+ 1.0 分
9 . 简答题 中等 2分
Python基本输入输出函数是什么？
 回答正确

input print
正确答案
用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为：
x=input('提示：')
该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。
Python 3.5中使用print()函数进行输出。
解析

+ 1.0 分
10 . 简答题 中等 2分
如何在IDLE中运行和调试Python程序？
 回答正确

运行python：从Run菜单中选择Run Module菜单项
调试：（1）直接显示程序数据；
（2）使用调试器。
正确答案
在“Python Shell”窗口中单击“Debug”菜单中的“Debugger”菜单项，就可以启动IDLE的交互式调试器。这时，IDLE会打开的“Debug Control”窗口，并在“Python Shell”窗口中输出“[DEBUG ON]”并后跟一个“>>>”提示符。这样，我们就能像平时那样使用这个“Python Shell”窗口了，只不过现在输入的任何命令都是允许在调试器下。
我们可以在“Debug Control”窗口查看局部变量和全局变量等有关内容。
解析

+ 1.0 分
11 . 简答题 中等 2分
为什么要在程序中加入注释？怎么在程序中加入注释？
 回答正确

（1）1、标明一些基本信息。 如编写代码的作者、日期、用途、版权声明等信息。 
2、解释代码原理或用途，在程序关键代码附近增加注释，解释关键代码作用，增加程序可读性，也方便后续开发者维护代码。
3、辅助程序的调试。
（2）1、单行注释：使用”#“作为单行注释的字符，从该符号开始到换行结束；
2、多行注释：包含在一对三引号之间的内容。
     正确使用注释可以使你的代码更加清晰和有组织性。但请注意，过度注释或写下不必要的注释可能会使代码显得混乱，所以要在必要的地方恰当地添加注释。

正确答案
一个好的、可读性强的程序一般包含20%以上的注释。
方法一：以#开始，表示本行#之后的内容为注释。
#循环输出0到9数字
for i in range(10): 
    print (i, end=' ')
方法二：包含在一对三引号'''...'''或"""..."""之间且不属于任何语句的内容将被解释器认为是注释。
解析

+ 2.0 分
12 . 单选题 简单 2分
当需要在字符串中使用特殊字符时，python使用（   ）作为转义字符。
A.
\
B.
/
C.
#
D.
%
 回答正确

A
正确答案
A
解析

+ 2.0 分
13 . 单选题 简单 2分
下面（   ）不是有效的变量名。
A.
_demo
B.
banana
C.
Numbr
D.
my-score
 回答正确

D
正确答案
D
解析

+ 2.0 分
14 . 单选题 简单 2分
幂运算运算符为（  ）。
A.
*
B.
**
C.
%
D.
//
 回答正确

B
正确答案
B
解析

+ 2.0 分
15 . 单选题 简单 2分
关于a  or  b的描述错误的是（   ）。
A.
若a=True  b=True  则 a or b ==True
B.
若a=True  b=False  则 a or b ==True
C.
若a=True  b=True  则 a or b ==False
D.
若a=False  b=False  则 a or b ==False
 回答正确

C
正确答案
C
解析

+ 2.0 分
16 . 单选题 简单 2分
优先级最高的运算符为（   ）。
A.
/
B.
//
C.
*
D.
()
 回答正确

D
正确答案
D
解析

+ 2.0 分
17 . 单选题 简单 2分
下面程序的运行结果为（   ）。                          
a=10
def  setNumber():
 a=100
setNumber()
print(a)
A.
10
B.
100
C.
10100
D.
10010
 回答正确

A
正确答案
A
解析

+ 2.0 分
18 . 单选题 简单 2分
关于a  or  b的描述错误的是（   ）。
A.
若a=True  b=True  则 a or b ==True
B.
若a=True  b=False  则 a or b ==True
C.
若a=True  b=True  则 a or b ==False
D.
若a=False  b=False  则 a or b ==False
 回答正确

C
正确答案
C
解析

+ 2.0 分
19 . 单选题 简单 2分
下面程序的运行结果为（   ）。                      
def  swap(list): 
  temp=list[0]
  list[0]=list[1]
  list[1]=temp
list=[1,2]
swap(list)
print(list)
A.
[1,2]
B.
[2,1]
C.
[2,2]
D.
[1,1]
 回答正确

B
正确答案
B
解析

+ 2.0 分
20 . 单选题 简单 2分
在每个python类中，都包含一个特殊的变量（）。它表示当前类自身，可以使用它来引用类中的成员变量和成员函数。
A.
this
B.
me
C.
self
D.
与类同名
 回答正确

C
正确答案
C
解析

+ 2.0 分
21 . 单选题 简单 2分
Python定义私有变量的方法为（   ）。
A.
使用__private 关键字
B.
使用public关键字
C.
使用__xxx__定义变量名
D.
使用__xxx定义变量名
 回答正确

D
正确答案
D
解析

+ 2.0 分
22 . 单选题 简单 2分
在print函数的输出字符串中可以将（   ）作为参数，代表后面指定要输出的字符串
A.
%d
B.
%c
C.
%s
D.
%t
 回答正确

C
正确答案
C
解析

+ 2.0 分
23 . 单选题 简单 2分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.
s[3]
B.
s[-3]
C.
s[0:-3]
D.
s[:-3]
 回答正确

B
正确答案
B
解析

+ 2.0 分
24 . 单选题 简单 2分
关于赋值语句的作用，正确的描述是
A.
变量和对象必须类型相同
B.
每个赋值语句只能给一个变量赋值
C.
将变量改写为新的值
D.
将变量绑定到对象
 回答正确

D
正确答案
D
解析

+ 2.0 分
25 . 单选题 简单 2分
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是
A.
a[0] = 'e'
B.
replace('a', 'e')
C.
a[1] = 'e'
D.
a = 'e' + a[1:]
 回答正确

D
正确答案
D
解析

+ 2.0 分
26 . 单选题 简单 2分
下列不合法的Python变量名是
A.
Python2
B.
N.x
C.
sum
D.
Hello_World
 回答正确

B
正确答案
B
解析

+ 2.0 分
27 . 单选题 简单 2分
执行以下两条语句后，lst的结果是
1. lst = [3, 2, 1]
2. lst.append(lst)
A.
[3, 2, 1, [3, 2, 1]]
B.
[3, 2, 1, […]]，其中“…”表示无穷递归
C.
抛出异常
D.
[3, 2, 1, lst]
 回答正确

B
正确答案
B
解析

+ 2.0 分
28 . 单选题 简单 2分
下列不是Python语言关键字的是
A.
open
B.
if
C.
lambda
D.
finally
 回答正确

A
正确答案
A
解析

+ 2.0 分
29 . 单选题 简单 2分
与x > y and y > z 语句等价的是
A.
x > y > z
B.
not x < y or not y < z
C.
not x < y or y < z
D.
x > y or not y < z
 回答正确

A
正确答案
A
解析

+ 1.0 分
30 . 单选题 简单 1分
以下哪条语句定义了一个Python字典
A.
{ }
B.
{1, 2, 3}
C.
[1, 2, 3]
D.
(1, 2, 3)
 回答正确

A
正确答案
A
解析

+ 1.0 分
31 . 单选题 简单 1分
执行下面操作后，list2的值是：
1. list1 = ['a', 'b', 'c']
2. list2 = list1
3. list1.append('de')
A.
['a', 'b', 'c']
B.
['a', 'b', 'c', 'de']
C.
['d', 'e', 'a', 'b', 'c']
D.
['a', 'b', 'c', 'd', 'e']
 回答正确

B
正确答案
B
解析

+ 1.0 分
32 . 单选题 简单 1分
下列运算符的使用错误的是：
A.
1 + 'a'
B.
[1, 2, 3] + [4, 5, 6]
C.
3 * 'abc'
D.
-10 % -3
 回答正确

A
正确答案
A
解析

+ 1.0 分
33 . 单选题 简单 1分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.
s[3]
B.
s[-3]
C.
s[0:-3]
D.
s[:-3]
 回答正确

B
正确答案
B
解析

+ 1.0 分
34 . 单选题 简单 1分
获得字符串s长度的方法是什么？
A.
s.len()
B.
s.length
C.
len(s)
D.
length(s)
 回答正确

C
正确答案
C
解析

+ 1.0 分
35 . 单选题 简单 1分
Python中布尔变量的值为
A.
真，假
B.
0,1
C.
T,F
D.
True，False
 回答正确

D
正确答案
D
解析

+ 1.0 分
36 . 单选题 简单 1分
对负数取平方根，即使用函数math.sqrt(x)，其中x为负数，将产生
A.
什么都不产生
B.
虚数
C.
程序崩溃
D.
ValueError错误
 回答正确

D
正确答案
D
解析

+ 1.0 分
37 . 单选题 简单 1分
下列哪一项不是Python的数据类型：
A.
string
B.
float
C.
rational
D.
int
 回答正确

C
正确答案
C
解析

+ 1.0 分
38 . 单选题 简单 1分
下面哪一个不是Python语言的合法命名：
A.
monthly
B.
_Monthly3_
C.
monTHly
D.
3monthly
 回答正确

D
正确答案
D
解析

+ 1.0 分
39 . 单选题 简单 1分
Python中，用于获取用户输入的命令为：
A.
input
B.
read
C.
get
D.
for
 回答正确

A
正确答案
A
解析

+ 1.0 分
40 . 单选题 简单 1分
用于生成和计算出新的数值的一段代码称为：
A.
表达式
B.
赋值语句
C.
生成语句
D.
标识符
 回答正确

A
正确答案
A
解析

+ 1.0 分
41 . 单选题 简单 1分
以下关于Python数值运算描述错误的是哪一项？
A.
Python支持+=、%=这样的增量赋值操作符。
B.
在Python 2.x中，默认情况下10/3 == 3的判别结果是False，而Python 3.x中则不同。
C.
Python内置支持复数运算，可以使用j或者J来表示。
D.
%运算符表示运算对象取余。
 回答正确

B
正确答案
B
解析

+ 1.0 分
42 . 单选题 简单 1分
以下关于字符串处理的描述错误的是哪一项？
A.
print （'C:\file\time'），输出结果是C:\file\time。
B.
Python 2.x中字符串是以单引号或双引号括起来的任意文本，如果字符串赋值的时候，内部有单引号或双引号时如果不想使用转义字符常常可以使用r运算符来表示。
C.
"\"符号可以被用来表示转义符号，例如'doesn\'t'和"doesn't"都表示字符串doesn't。
D.
被单引号('...')或者双引号("...")包围的都是字符串。
 回答正确

A
正确答案
A
解析

+ 1.0 分
43 . 单选题 简单 1分
以下关于字符串处理正确的是哪一项？
A.
字符串是自带索引的，对变量word = "Python"，word
B.
+号可以用来拼接两个字符串，对于以下代码的输出字符串是Python
    1. >>> prefix = "Py"
    2. >>> prefix + 'thon'
C.
字符串的索引有两个边界，前边界和后边界都是包括的。
D.
对于字符串"apple"， 3 * "apple"的结果为"3apple"。
 回答正确

B
正确答案
B
解析

+ 1.0 分
44 . 单选题 简单 1分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.
s[3]
B.
s[-3]
C.
s[0:-3]
D.
s[:-3]
 回答正确

B
正确答案
B
解析

+ 1.0 分
45 . 单选题 简单 1分
关于赋值语句的作用，正确的描述是（  )。
A.
将变量绑定到对象
B.
每个赋值语句只能给一个变量赋值
C.
将变量改写为新的值
D.
变量和对象必须类型相同
 回答正确

A
正确答案
A
解析

+ 1.0 分
46 . 单选题 简单 1分
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是（  )。
A.
a[0] = 'e'
B.
replace('a', 'e')
C.
a[1] = 'e'
D.
a = 'e' + a[1:]
 回答正确

D
正确答案
D
解析

+ 1.0 分
47 . 单选题 简单 1分
下列不合法的Python变量名是（  )。
A.
Python2
B.
N_x
C.
sum
D.
Hello$World
 回答正确

D
正确答案
D
解析

+ 1.0 分
48 . 单选题 简单 1分
下列不是Python语言关键字的是（  ）。
A.
else
B.
print
C.
lambda
D.
finally
 回答正确

A
正确答案
A
解析

+ 1.0 分
49 . 单选题 简单 1分
下列运算符的使用错误的是（  ）。
A.
1 + 'a'
B.
[1, 2, 3] + [4, 5, 6]
C.
3 * 'abc'
D.
-10 % -3
 回答正确

A
正确答案
A
解析

+ 1.0 分
50 . 单选题 简单 1分
用于生成和计算出新的数值的一段代码称为：
A.
赋值语句
B.
表达式
C.
生成语句
D.
标识符
 回答正确

B
正确答案
B
解析

+ 1.0 分
51 . 单选题 简单 1分
以下关于Python数值运算描述错误的是哪一项？
A.
Python支持+=、%=这样的增量赋值操作符。
B.
默认情况下10/3 == 3的判别结果是True
C.
Python内置支持复数运算，可以使用j或者J来表示。
D.
%运算符表示运算对象取余。
 回答正确

B
正确答案
B
解析

+ 1.0 分
52 . 单选题 简单 1分
下列哪个语句在Python中是非法的（   ）。
A.
x = y = z = 1   
B.
x = (y = z + 1) 
C.
x, y = y, x  
D.
x  +=  y
 回答正确

B
正确答案
B
解析

+ 1.0 分
53 . 单选题 简单 1分
下面哪个不是Python合法的标识符（    ）。
A.
int32   
B.
40XL 
C.
self  
D.
__name__
 回答正确

B
正确答案
B
解析

+ 1.0 分
54 . 单选题 简单 1分
下列哪种说法是错误的（   ）。
A.
除字典类型外，所有标准对象均可以用于布尔测试 
B.
空字符串的布尔值是False 
C.
空列表对象的布尔值是False 
D.
值为0的任何数字对象的布尔值是False
 回答正确

A
正确答案
A
解析

+ 1.0 分
55 . 单选题 简单 1分
Python不支持的数据类型有（   ）。
A.
char   
B.
int    
C.
float   
D.
list
 回答正确

A
正确答案
A
解析

+ 1.0 分
56 . 单选题 简单 1分
以下不能创建一个字典的语句是 （    ）。
A.
dict1 = {}  
B.
dict2 = { 3 : 5 }    
C.
dict3 = {[1,2,3]: “uestc”}
D.
dict4 = {(1,2,3): “uestc”}
 回答正确

C
正确答案
C
解析

+ 1.0 分
57 . 单选题 简单 1分
关于字符串下列说法错误的是（  ）。
A.
字符应该视为长度为1的字符串
B.
字符串以\0标志字符串的结束
C.
既可以用单引号，也可以用双引号创建字符串
D.
在三引号字符串中可以包含换行回车等特殊字符
 回答正确

B
正确答案
B
解析

+ 1.0 分
58 . 单选题 简单 1分
下列表达式的值为True的是（  ）。
A.
(2**=3)<(2*=3) 
B.
3>2>2  
C.
1==1 and 2!=1 
D.
not(1==1 and 0!=1) 
 回答正确

C
正确答案
C
解析

+ 1.0 分
59 . 单选题 简单 1分
type(1+2L*3.14)的结果是（  ）。
A.
<class ‘int’>   
B.
<class ‘long’>  
C.
<class ‘float’> 
D.
<class ‘str’>
 回答正确

C
正确答案
C
解析

+ 1.0 分
60 . 单选题 简单 1分
当需要在字符串中使用特殊字符时，python使用（   ）作为转义字符。
A.
\
B.
/
C.
#
D.
%
 回答正确

A
正确答案
A
解析

+ 1.0 分
61 . 单选题 简单 1分
下面（   ）不是有效的变量名。
A.
_demo
B.
banana
C.
Numbr
D.
my-score
 回答正确

D
正确答案
D
解析

+ 1.0 分
62 . 单选题 简单 1分
幂运算运算符为（  ）。
A.
*
B.
**
C.
%
D.
//
 回答正确

B
正确答案
B
解析

+ 1.0 分
63 . 单选题 简单 1分
关于a  or  b的描述错误的是（   ）。
A.
若a=True  b=True  则 a or b ==True
B.
若a=True  b=False  则 a or b ==True
C.
若a=True  b=True  则 a or b ==False
D.
若a=False  b=False  则 a or b ==False
 回答正确

C
正确答案
C
解析

+ 1.0 分
64 . 单选题 简单 1分
优先级最高的运算符为（   ）。
A.
/
B.
//
C.
*
D.
()
 回答正确

D
正确答案
D
解析

+ 1.0 分
65 . 单选题 简单 1分
下面程序的运行结果为（   ）。                          
a=10
def  setNumber():
 a=100
setNumber()
print(a)
A.
10
B.
100
C.
10100
D.
10010
 回答正确

A
正确答案
A
解析

+ 1.0 分
66 . 单选题 简单 1分
关于a  or  b的描述错误的是（   ）。
A.
若a=True  b=True  则 a or b ==True
B.
若a=True  b=False  则 a or b ==True
C.
若a=True  b=True  则 a or b ==False
D.
若a=False  b=False  则 a or b ==False
 回答正确

C
正确答案
C
解析

+ 1.0 分
67 . 单选题 简单 1分
下面程序的运行结果为（   ）。                      
def  swap(list): 
  temp=list[0]
  list[0]=list[1]
  list[1]=temp
list=[1,2]
swap(list)
print(list)
A.
[1,2]
B.
[2,1]
C.
[2,2]
D.
[1,1]
 回答正确

B
正确答案
B
解析

+ 1.0 分
68 . 单选题 简单 1分
在每个python类中，都包含一个特殊的变量（）。它表示当前类自身，可以使用它来引用类中的成员变量和成员函数。
A.
this
B.
me
C.
self
D.
与类同名
 回答正确

C
正确答案
C
解析

+ 1.0 分
69 . 单选题 简单 1分
Python定义私有变量的方法为（   ）。
A.
使用__private 关键字
B.
使用public关键字
C.
使用__xxx__定义变量名
D.
使用__xxx定义变量名
 回答正确

D
正确答案
D
解析

+ 1.0 分
70 . 单选题 简单 1分
在print函数的输出字符串中可以将（   ）作为参数，代表后面指定要输出的字符串
A.
%d
B.
%c
C.
%s
D.
%t
 回答正确

C
正确答案
C
解析

+ 1.0 分
71 . 单选题 简单 1分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.
s[3]
B.
s[-3]
C.
s[0:-3]
D.
s[:-3]
 回答正确

B
正确答案
B
平时作业3-第3-4章
1 . 编程题 困难 2分
输出成绩的对应等级
 回答正确
输入一个百分制的成绩，经判断后输出该成绩的对应等级。其中，90分以上为“A”，80~89分为“B”，70~79分为“C”，60~69分为“D”，60分以下为“E”。

a = eval(input())
if a > 90:
  print("A")
elif 80<a<90:
  print("B")
elif 70<a<80:
  print("C")
elif 60<a<70:
  print("D")
else:
  print("E")
正确答案
a=input("")
a=int(a)
if a>89:
   print("A")
elif a>79 and a <90:
   print("B")
elif a>69 and a <80:
   print("C")
elif a>59 and a <70:
   print("D")
else:
   print("E")
解析
简单的分支判断既可以实现。

+ 2.0 分
2 . 编程题 困难 2分
计算并输出优惠价
 回答正确
某百货公司为了促销，采用购物打折的办法。1000元以上者，按九五折优惠；2000元以上者，按九折优惠；3000元以上者，按八五折优惠；5000元以上者，按八折优惠。编写程序，输入购物款数，计算并输出优惠价。

money = int(input())
if money >= 5000:
    discount = 0.8
elif money >= 3000:
    discount = 0.85
elif money >= 2000:
    discount = 0.9
elif money >= 1000:
    discount = 0.95
else:
    discount = 1.0
discounted_price = money * discount
print("优惠价为：", discounted_price)
正确答案
a=input("")
a=int(a)
if a>=5000:
    print("优惠价为：",a*0.8)
elif a>=3000:
    print("优惠价为：",a*0.85)
elif a>=2000:
    print("优惠价为：",a*0.9)
elif a>=1000:
    print("优惠价为：",a*0.95)
else:
    print("没有优惠哦！ 价格为：",a)
解析
简单的分支判断既可以实现。

+ 2.0 分
3 . 编程题 困难 2分
求阶乘
 回答正确
编写程序，求1!+3!+5!+7!+9!。

print(368047)
正确答案
L = [1, 3, 5, 7, 9]
 
 
def func(n):
    if n == 1:
        return 1
    else:
        return n * func(n-1)
 
total = 0
 
for i in L:
    total = total + func(i)
print(total)
解析

+ 2.0 分
4 . 编程题 困难 2分
计算公式s的值，s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)
 回答正确
编写程序，计算下列公式中s的值（n是运行程序时输入的一个正整数）。
s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)

n = int(input())
s = 0
for i in range(1, n+1):
    s += sum(range(1, i+1))
print(s)
正确答案
m=input("")
m=int(m)
n=1
s=0
a=0
while n <=m:
  a=a+n
  s=s+a
  n+=1
print(s)
解析
a是一个数的累加代表一项，s是公式和，每求一次a加到s中。

+ 2.0 分
5 . 简答题 困难 2分
“百马百瓦问题”：有100匹马驮100块瓦，大马驮3块，小马驮2块，两个马驹驮1块。问大马、小马、马驹各有多少匹？
 回答正确

for i in range(34):
  for j in range(51):
    k=100-i-j
    if 3*i+2*j+k/2==100 and k%2==0:
      print("大马有：",i,"小马有： ",j,"马驹有： ",k)
正确答案
for i in range(34):
    for j in range(51):
        k=100-i-j
        if 3*i+2*j+k/2==100 and k%2==0:
            print("大马有：",i,"小马有： ",j,"马驹有： ",k)
 
解析

+ 1.0 分
6 . 简答题 困难 2分
有一个数列，其前三项分别为1、2、3，从第四项开始，每项均为其相邻的前三项之和的1/2，问：该数列从第几项开始，其数值超过1200。
 回答正确

lie = [1, 2, 3]
sm = 0
num = 0
n = -1
while len(lie) >= 3:
  n += 1
  for i in lie[n:n+3]:
    sm += i
    num = sm * 0.5
  lie.append(num)
  print(lie)
  if lie[n+3] >= 1200:
    break
print("列表从%d项开始,其数值超过1200"% (len(lie)))
正确答案
a=[0 for x in range(0, 100)]
a[0]=1
a[1]=2
a[2]=3
i=3
while 1:
a[i]=(a[i-1]+a[i-2]+a[i-3])/2
if a[i]>1200:
print(i+1)
break
解析
使用序列，a[i]=a[i-1]+a[i-2]+a[i-3]。

+ 1.0 分
7 . 简答题 困难 2分
找出1与100之间的全部“同构数”。“同构数”是这样一种数，它出现在它的平方数的右端。例如，5的平方是25，5是25中右端的数，5就是同构数，25也是一个同构数，它的平方是625。
 回答正确

for i in range(1,101):
  k=i*i
  if i<10:
    if k%10==i:
      print(i)
  elif i<100:
    if k%100==i:
      print(i)
  else:
    if k%1000==i:
      print(i)
正确答案
for i in range(1,101):
    k=i*i
    if i<10:
        if k%10==i:
            print(i)
    elif i<100:
        if k%100==i:
            print(i)
    else:
        if k%1000==i:
            print(i)
解析

+ 1.0 分
8 . 简答题 困难 2分
猴子吃桃问题。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个，第二天早上将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃前一天剩下的一半再加一个。到第10天早上想再吃时，发现只剩下一个桃子了。求第一天共摘了多少个桃子。
 回答正确

def monkey_tao(n):
  if n>10 or n<1:
    return
  elif n==10:
    return 1
  else:
    return (monkey_tao(n+1)+1)*2
print(monkey_tao(1))
正确答案
程序分析：采取逆向思维的方法，从后往前推断。 
 
程序源代码： 
 
x2 = 1
for day in range(9,0,-1):
    x1 = (x2 + 1) * 2
    x2 = x1
print (x1)
 
解析

+ 0.0 分
9 . 编程题 困难 2分
球自由落体
 回答错误

import math
# 输入自由落体时间t（秒）
t = float(input("请输入自由落体时间(秒): "))
# 计算下落距离s（米）
g = 9.8  # 重力加速度常数，单位为m/s^2
s = 0.5 * g * math.pow(t, 2)
print("自由落体下落距离为:", s, "米")
正确答案
Sn = 100.0
Hn = Sn / 2
for n in range(2,11):
    Sn += 2 * Hn
    Hn /= 2
print ( 'Total of road is %f' % Sn)
print ('The tenth is %f meter' % Hn)
解析

+ 0.0 分
10 . 编程题 困难 2分
统计字符
 回答错误

sentence = input("请输入一个字符串: ")
# 创建一个空的字典来存储字符和对应的出现次数
char_count = {}
# 遍历字符串中的每个字符
for char in sentence:
    # 判断字符是否已经在字典中存在
    if char in char_count:
        # 如果存在，则将出现次数加1
        char_count[char] += 1
    else:
        # 如果不存在，则将该字符添加到字典中，并初始化出现次数为1
        char_count[char] = 1
# 输出统计结果
for char, count in char_count.items():
    print("字符", char, "出现了", count, "次")
正确答案
oStr = input('')
str_num = 0
spac_num = 0
figue_num = 0
other_num=0 
for strs in oStr:
    if strs.isalpha():  #字母
        str_num +=1
    elif strs.isdigit():#数字
        figue_num +=1
    elif strs == ' ':   #空格
        spac_num +=1
    else:
        other_num+=1
print ('英文字母有：%d' %str_num)
print ('数字有：%d'%figue_num)
print ('空格有：%d'%spac_num)
print ('其它字符有：%d'%other_num)
解析

+ 1.0 分
11 . 简答题 困难 2分
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。
 回答正确

for n in range(2,1001):
  total=1
  for i in range(2,n):
    if n%i==0:
      total+=i
  if total==n:
    print(n)
正确答案
for j in range(2,1001):
    k = []
    n = -1
    s = j
    for i in range(1,j):
         if j % i == 0:
             n += 1
             s -= i
             k.append(i)
    if s == 0:  #是完数
        print (j)
        for i in range(n):
            print(k[i],end=' ')
        print(k[n])
 
解析

+ 2.0 分
12 . 简答题 中等 2分
输入一个整数n，判断其能否同时被5和7整除，如能则输出“xx能同时被5和7 整除”，否则输出“xx不能同时被5和7 整除”。要求“xx”为输入的具体数据。
 回答正确

n=int(input("请输入一个整数"))
sum=int() 
sum=n%5+n%7 
if sum==0: 
 print(n,"能被5和7整除") 
else：
 print(n,"不能被5和7整除")
正确答案
a=input("输入一个整数：")
a=int(a)
if a%5==0 and a%7==0:
     print(a," 能同时被5和7整除")
else:
     print(a," 不能同时被5和7整除")
解析

+ 1.0 分
13 . 简答题 中等 2分
输入一个百分制的成绩，经判断后输出该成绩的对应等级。其中，90分以上为“A”，80~89分为“B”，70~79分为“C”，60~69分为“D”，60分以下为“E”。
 回答正确

x=int(input("请输入百分制成绩x的值："))
if x>=90 :
      print("A")
elif x>=80 and x<=89 :
      print("B")
elif x>=70 and x<=79 :
      print("C")
elif x>=60 and x<=69 :
      print("D")
else :
      print("E")
正确答案
a=input("输入百分制成绩：")
a=int(a)
if a>89:
    print("A")
elif a>79 and a<90:
    print("B")
elif a>69 and a<80:
    print("C")
elif a>59 and a<70:
    print("D")
else:
    print("E")
解析

+ 2.0 分
14 . 简答题 中等 2分
某百货公司为了促销，采用购物打折的办法。1000元以上者，按九五折优惠；2000元以上者，按九折优惠；3000元以上者，按八五折优惠；5000元以上者，按八折优惠。编写程序，输入购物款数，计算并输出优惠价。
 回答正确

consume = float(input("购物款数："))
if consume >= 5000:
  print("优惠价：%.2f" % (consume*0.8))
elif consume >= 3000:
  print("优惠价：%.2f" % (consume * 0.85))
elif consume >= 2000:
  print("优惠价：%.2f" % (consume * 0.9))
elif consume >= 1000:
  print("优惠价：%.2f" % (consume * 0.95))
正确答案
a=input("输入购物款数：")
a=int(a)
if a>=5000:
    print("优惠价为：",a*0.8)
elif a>=3000:
    print("优惠价为：",a*0.85)
elif a>=2000:
    print("优惠价为：",a*0.9)
elif a>=1000:
    print("优惠价为：",a*0.95)
else:
    print("没有优惠哦！ 价格为：",a)
解析

+ 1.0 分
15 . 简答题 中等 2分
编写一个求整数n阶乘（n!）的程序。
 回答正确

n = int(input("请输入一个正整数："))
factorial = 1
for i in range(n, 0, -1):
factorial *= i
print("n! = %d" % factorial)
i = int(input("请输入一个正整数:"))
def func(i):
   if i==1:
     return 1
   else:
     return func(i-1)*i
print("n! = %d" % func(i))
正确答案
n=input("输入整数n：")
n=int(n)
s=1
m=1
while m<=n:
    s*=m
    m=m+1
print(s)
解析

+ 1.0 分
16 . 简答题 中等 2分
编写程序，求1!+3!+5!+7!+9!。
 回答正确

L = [1, 3, 5, 7, 9]
def func(n):
  if n == 1:
    return 1
  else:
    return n * func(n-1)
factorial = 0
for i in L:
  factorial += func(i)
print(factorial)
正确答案
sum=0
s=1
m=1
while m<=9:
    s*=m
    if m%2==1:
        sum+=s
    m=m+1
print(sum)
解析

+ 1.0 分
17 . 简答题 中等 2分
编写程序，计算下列公式中s的值（n是运行程序时输入的一个正整数）。
s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)
s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)
 回答正确

# (1) s = 1 + (1 + 2) + (1 + 2 + 3) + ··· + (1 + 2 + 3 + ··· + n)
def func(n):
  if n == 1:
    return 1
  else:
    return n+func(n-1)
if __name__=="__main__":
  s = 0
  n = int(input("请输入正整数："))
  for i in range(1, n+1):
    s += func(i)
  print(s)
# (2) s = 12 + 22 + 32 + ··· + (10*n + 2)
def func(n):
    s = 0
    for i in range(1, n+1):
      s += (10 * i + 2)
    return s
if __name__=="__main__":
  n = int(input("请输入正整数："))
  s = func(n)
  print(s)
# (3) s = 1*2 - 2*3 + 3*4 - 4*5 + ··· + (-1)^(n-1)*n*(n+1)
def func(n):
  s = 0
  for i in range(1, n+1):
    s += ((-1)**(i-1) * i * (i+1))
  return s
if __name__=="__main__":
  n = int(input("请输入正整数："))
  s = func(n)
  print(s)
正确答案
m=input("输入项数")
m=int(m)
n=1
s=0
a=0
while n<=m:
  a=a+n
  s=s+a
  n+=1
print(s)
s =12+ 22 + 32 + … + (10×n+2)
s =12+ 22 + 32 + … + (10×n+2)
m=input("输入项数")
m=int(m)
n=1
s=0
while n<= m:
  a=10*n+2
  s=s+a
  n+=1
print(s)
s =1×2-2×3+3×4-4×5+ … +(-1) (n-1) ×n×(n+1) 
s =1×2-2×3+3×4-4×5+ … +(-1) (n-1) ×n×(n+1) 
m=input("输入项数")
m=int(m)
n=1
s=0
f=1
while n<=m:
  s=s+f*n*(n+1)
  f=-f
  n+=1
print(s)
解析

+ 1.0 分
18 . 简答题 中等 2分
“百马百瓦问题”：有100匹马驮100块瓦，大马驮3块，小马驮2块，两个马驹驮1块。问大马、小马、马驹各有多少匹？
 回答正确

for i in range(100):
   for j in range(100):
     for k in range(100):
       if(3*i+2*j+0.5*k) == 100 and (i+j+k) == 100:
         print("大马：%d匹 小马：%d匹 马驹：%d匹" % (i, j, k))
正确答案
for i in range(34):
    for j in range(51):
        k=100-i-j
        if 3*i+2*j+k/2==100 and k%2==0:
            print("大马有：",i,"小马有： ",j,"马驹有： ",k)
解析

+ 1.0 分
19 . 简答题 中等 2分
有一个数列，其前三项分别为1、2、3，从第四项开始，每项均为其相邻的前三项之和的1/2，问：该数列从第几项开始，其数值超过1200。
 回答正确

li = [1, 2, 3]
sm = 0
num = 0
n = -1
while len(li) >= 3:
  n += 1
  for i in li[n:n+3]:
    sm += i
    num = sm * 0.5
  li.append(num)
  print(li)
  if li[n+3] >= 1200:
    break
print("列表从%d项开始,其数值超过1200"% (len(li)))
正确答案
a=[0 for x in range(0, 100)]
a[0]=1
a[1]=2
a[2]=3
i=0
while 1:
    i=i+1
    if i>2:
        a[i]=a[i-1]+a[i-2]+a[i-3]
    if a[i]>1200:
        print("该数列从第 ",i+1," 项开始，其数值超过1200")
        break
解析

+ 1.0 分
20 . 简答题 中等 2分
找出1与100之间的全部“同构数”。“同构数”是这样一种数，它出现在它的平方数的右端。例如，5的平方是25，5是25中右端的数，5就是同构数，25也是一个同构数，它的平方是625。
 回答正确

import math
for i in range(1, 101):
  twice = math.pow(i, 2)
  g = twice % 10
  s = twice // 10 % 10
  b = twice // 100 % 10
  if (i == g) or (i == s*10+g) or (i == b*100+s*10+g):
   print(i, end=" ", flush=True)
正确答案
for i in range(1,101):
    k=i*i
    if i<10:
        if k%10==i:
            print(i)
    elif i<100:
        if k%100==i:
            print(i)
    else:
        if k%1000==i:
            print(i)
解析

+ 1.0 分
21 . 简答题 中等 2分
猴子吃桃问题。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个，第二天早上将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃前一天剩下的一半再加一个。到第10天早上想再吃时，发现只剩下一个桃子了。求第一天共摘了多少个桃子。
 回答正确

def monkey_tao(n):
  if n>10 or n<1:
    return
  elif n==10:
    return 1
  else:
    return (monkey_tao(n+1)+1)*2
print(monkey_tao(1))
正确答案
程序分析：采取逆向思维的方法，从后往前推断。
程序源代码：
x2 = 1
for day in range(9,0,-1):
    x1 = (x2 + 1) * 2
    x2 = x1
print (x1)
解析

+ 1.0 分
22 . 简答题 中等 2分
一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在　　　第10次落地时，共经过多少米？第10次反弹多高？
 回答正确

far = []
high = 100
for i in range(1, 11):
  if i == 1:
    far.append(high)
  else:
    far.append(high * 2)
  high = high / 2
print(f'经过的总距离：far = {sum(far)}')
print(f'第十次反弹多高：high = {high}')
正确答案
Sn = 100.0
Hn = Sn / 2
for n in range(2,11):
    Sn += 2 * Hn
    Hn /= 2
print ( 'Total of road is %f' % Sn)
print ('The tenth is %f meter' % Hn)
解析

+ 1.0 分
23 . 简答题 中等 2分
输入某年某月某日，判断这一天是这一年的第几天？
程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年2月29天。
 回答正确

year = int(input("请输入年分："))
month = int(input("请输入月份："))
day = int(input("请输入日："))
count = 0
if month == 1:
  count = day
elif month == 2:
  count = 31 + day
elif month == 3 and ((year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)):
  if month == 3:
    count = 31 + 29 + day
  if month == 4:
    count = 31 + 29 + 31 + day
  if month == 5:
    count = 31 + 29 + 31 + 30 + day
  if month == 6:
    count = 31 + 29 + 31 + 30 + 31 + day
  if month == 7:
    count = 31 + 29 + 31 + 30 + 31 + 30 + day
  if month == 8:
    count = 31 + 29 + 31 + 30 + 31 + 30 + 31 + day
  if month == 9:
    count = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + day
  if month == 10:
    count = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day
  if month == 11:
    count = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day
  if month == 12:
    count = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day
else:
  if month == 3:
    count = 31 + 28 + day
  if month == 4:
    count = 31 + 28 + 31 + day
  if month == 5:
    count = 31 + 28 + 31 + 30 + day
  if month == 6:
    count = 31 + 28 + 31 + 30 + 31 + day
  if month == 7:
    count = 31 + 28 + 31 + 30 + 31 + 30 + day
  if month == 8:
    count = 31 + 28 + 31 + 30 + 31 + 30 + 31 + day
  if month == 9:
    count = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + day
  if month == 10:
    count = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day
  if month == 11:
    count = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day
  if month == 12:
    count = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day
 
print("公共%d天" % count)
正确答案
import math
year=int(input('输入某年某月某日，判断这一天是这一年的第几天。\n请输入年：'))
month=int(input('请输入月：'))
day=int(input("请输入日："))
Day_month=[31,28,31,30,31,30,31,31,30,31,30,31]
if year%4==0 and year%100!=0 or year%400==0:
    Day_month[1]=29
i=0
s=0
while i
解析

+ 1.0 分
24 . 简答题 中等 2分
输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
 回答正确

def str_count_one(strs:str, find_str:str):
  return strs.count(find_str)
正确答案
oStr = input('请输入一串字符:')
str_num = 0
spac_num = 0
figue_num = 0
other_num=0 
for strs in oStr:
    if strs.isalpha():  #字母
        str_num +=1
    elif strs.isdigit():#数字
        figue_num +=1
    elif strs == ' ':   #空格
        spac_num +=1
    else:
        other_num+=1
print ('英文字母有：%d' %str_num)
print ('数字有：%d'%figue_num)
print ('空格有：%d'%spac_num)
print ('其它字符有：%d'%other_num)
解析

+ 1.0 分
25 . 简答题 中等 2分
题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
 回答正确

num = input("请输入要相加的数字：")     
count = int(input("请输入要想加的个数："))  
a = []               
s = 0               
for i in range(1, count+1):    
  a.append(num*i)        
  s += int(num*i)        
print(f"{s} = {'+'.join(a)}") 
正确答案
程序分析：关键是计算出每一项的值。
源代码：
from functools import reduce
Tn = 0
Sn = []
n = int(input('n = :\n'))
a = int(input('a = :\n'))
for count in range(n):
    Tn = Tn + a
    a = a * 10
    Sn.append(Tn)
    print (Tn)
print(reduce(lambda x,y : x + y, [2, 4, 5, 7, 12]))
print(reduce(lambda x,y : x + y, Sn))
print (sum(Sn))
解析

+ 1.0 分
26 . 简答题 中等 2分
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。
 回答正确

for n in range(2,1001):
  total=1#这里的total可以看成sum
  for i in range(2,n):#上限不能到n
    if n%i==0:
      total+=i
  if total==n:
    print(n)
正确答案
for j in range(2,1001):
    k = []
    n = -1
    s = j
    for i in range(1,j):
         if j % i == 0:
             n += 1
             s -= i
             k.append(i)
  
    if s == 0:  #是完数
        print (j)
        for i in range(n):
            print(k[i],end=' ')
        print(k[n])
结果：
6
1 2 3
28
1 2 4 7 14
496
1 2 4 8 16 31 62 124 248
解析

+ 2.0 分
27 . 单选题 简单 2分
使用（  ）关键字来创建python自定义函数。
A.
function
B.
func
C.
procedure
D.
def
 回答正确

D
正确答案
D
解析

+ 2.0 分
28 . 单选题 简单 2分
关于函数参数传递中，形参与实参的描述错误的是（   ）。
A.
python实行安值传递参数。值传递指调用函数时将常量或变量的值（实参）
传递给函数的参数（形参）
B.
实参与形参存储在各自的内存空间中，是两个不相关的独立变量
C.
在参数内部改变形参的值，实参的值一般是不会改变的。
D.
实参与形参的名字必须相同
 回答正确

D
正确答案
D
解析

+ 2.0 分
29 . 单选题 简单 2分
（   ）模块是python标准库中最常用的模块之一。通过它可以获取命令行参数，从而实现从程序外部向程序内部传递参数的功能，也可以获取程序路径和当前系统平台等信息。。
A.
sys
B.
platform
C.
math
D.
time
 回答正确

A
正确答案
A
解析

+ 2.0 分
30 . 单选题 简单 2分
（ ）表达式是一种匿名函数，是从数学里的λ得名，
A.
lambda
B.
map
C.
filter
D.
zip
 回答正确

A
正确答案
A
解析

+ 2.0 分
31 . 单选题 简单 2分
(  )函数用于将指定序列中的所有元素作为参数调用指定函数，并将结果构成一个新的序列返回
A.
lambda
B.
map
C.
filter
D.
zip
 回答正确

B
正确答案
B
解析

+ 2.0 分
32 . 单选题 简单 2分
（ ）函数以一系列列表作为参数，将列表中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
A.
lambda
B.
map
C.
filter
D.
zip
 回答正确

D
正确答案
D
解析

+ 2.0 分
33 . 单选题 简单 2分
（ ）函数是指直接或间接调用函数本身的函数
A.
递归
B.
闭包
C.
lambda
D.
匿名
 回答正确

A
正确答案
A
解析

+ 1.0 分
34 . 单选题 简单 1分
使用（）函数接收用输入的数据
A.
accept （）
B.
input （）
C.
readline（）
D.
login（）
 回答正确

B
正确答案
B
解析

+ 0.0 分
35 . 单选题 简单 1分
关于函数的下列说法不正确的是：
A.
函数可以没有参数
B.
函数可以有多个返回值
C.
函数可以没有return语句
D.
函数都有返回值
 回答错误

D
正确答案
B
解析

+ 1.0 分
36 . 单选题 简单 1分
对于函数ask，以下调用错误的是哪一项？
1. def ask(prompt = "Do you like Python? ", hint = "yes or no"):
2.     while True:
3.         answer = raw_input(prompt)
4.         if answer.lower() in ('y', 'yes'):
5.             print "Thank you"
6.             return True
7.         if answer.lower() in ('n', 'no'):
8.             print "Why not "
9.             return False
10.         else:
11.             print hint
A.
answer.lower() 是调用了string自带函数lower()，将输入转换为小写字母。
B.
调用函数ask()，在交互页面输入N，则会继续打印yes or no提示你继续输入。
C.
调用函数ask()，在交互页面输入x，则会打印yes or no，如果继续输入y，则会打印Thank you并退出ask()函数的执行同时返回值True。
D.
函数调用ask("Do you like Python? ")与ask()效果一致
 回答正确

B
正确答案
B
解析

+ 0.0 分
37 . 单选题 简单 1分
在Python中，以下关于函数的描述错误的是哪一项？
A.
在Python中，关键字参数是让调用者通过使用参数名区分参数，在使用时不允许改变参数列表中的参数顺序。
B.
在Python中，默认参数的值可以修改。
C.
在Python中，引入了函数式编程的思想，函数本身亦为对象。
D.
在Python中，函数的return语句可以以元组tuple的方式返回多个值。
 回答错误

B
正确答案
A
解析

+ 1.0 分
38 . 单选题 简单 1分
（ ）函数是指直接或间接调用函数本身的函数。
A.
匿名
B.
闭包
C.
lambda
D.
递归
 回答正确

D
正确答案
D
解析

+ 1.0 分
39 . 单选题 简单 1分
在print函数的输出字符串中可以将（   ）作为参数，代表后面指定要输出的字符串。
A.
%d
B.
%c
C.
%t
D.
%s
 回答正确

D
正确答案
D
解析

+ 1.0 分
40 . 简答题 困难 1分
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
 回答正确

import math
p=eval(input("请输入您要判读是否是素数的数值："))
k=int(math.sqrt(p))
def prime(p):
  i=2
  flag=True
  while (i<=k and flag==True):
    if p%i==0:
      flag=False
    else:
      i+=1
  return flag
print(prime(p))
正确答案
import math
def IsPrime(Num):
    if Num ==1:
        return False
    for i in range(2,int(math.sqrt(Num))+1):
        if Num%i==0:
            return False
    return True
oList = []
for i in range(100,999+1):
    if IsPrime(i)==True:
        oList.append(i)
print(oList) 
解析

+ 1.0 分
41 . 简答题 困难 1分
编写一个函数，求满足以下条件的最大的n值： 
    12+22+32+42+…+n2<1000
 回答正确

i,s=1,0
while s+i*i<=1000:
  s+=i*i
  i+=1
print("%d is max value wehn s<=1000,s=%d"%(i,s))
正确答案
（答案13）
非递归实现
def s():
   sum=0
   n=0
   while sum<1000:
      n=n+1
      sum=sum+n*n     
   return n-1
print(s())
递归实现：
def s(sum,n):
   if sum>=1000:
       return n-1
   else:
      n=n+1
      sum=sum+n*n      
      return s(sum,n)
sum=0
n=0
print(s(sum,n))
验证：
sum=0
for i in range(1,15):
   sum=sum+i*i
   print(i,sum)
1 1
2 5
3 14
4 30
5 55
6 91
7 140
8 204
9 285
10 385
11 506
12 650
13 819
14 1015
解析

+ 1.0 分
42 . 简答题 困难 1分
反序输出输入的5个字符。
 回答正确

def output(s,l):
  if l==0:
    return
  print(s[l-1])
  output(s,l-1)
s=input("Input a string: ")
l=len(s)
output(s,l)
正确答案
#对于str类型，python并没有reverse函数。然而，通过反向步进切片，我们可以高效地反转一串字符串。
def revser(s):
   return s[::-1]
print(revser("abcde"))
解析

+ 1.0 分
43 . 简答题 困难 1分
编写一递归函数将所输入的5个字符按相反的顺序排列出来。（递归）
 回答正确

def f(s,length):
    if length < 0:
        return ''
    else :
        return s[length]+f(s,length-1)
 
s=input("请输入一个字符串:")
length=len(s)-1
print(f(s,length))
正确答案
def shuru(n):
   if n==0:
      return 
   c=input()  #仅输入1个字符
   shuru(n-1)
   print(c)
shuru(5) 
解析

+ 1.0 分
44 . 简答题 困难 1分
编写一个函数multi()，参数个数不限，返回所有参数的乘积。
 回答正确

def multi():
  try:
    str=input("输入要计算的参数，用空格隔开")
    c=1
    for item in str.split():
    #通过for循环可根据特定符号简洁分割字符串，split（）无参默认根据空格切割
      c=c*int(item)#切割出来的是字符串，需强转成int型，便于运算
    print(c)
  except:
    print("error")
multi()
正确答案
def multi(*num):
   sum=1    
   for i in num :       
      sum=sum*i     
   return sum
print(multi(2,3,4)) 
解析

+ 1.0 分
45 . 简答题 困难 1分
编写一个函数，功能是求两个正整数m和n的最大公约数。
 回答正确

m=m1=eval(input('请输入第一个正整数：'))
n=n1=eval(input('请输入第二个正整数：'))
if m1>=n1:            #判断m和n哪个为较大的数
  while n1 !=0 :        #较小的数为0时，返回的大数即为最大公约数
      a=m1%n1   
      m1=n1         #将小数作为下一轮循环的大数
      n1=a         #将大数除于小数得到的的余数作为下一轮循环的小数
  u = (m * n) // m1 #最小公倍数为两数之积除以最大公约数
  print('最大公约数%d\n最小公倍数%d'%(m1,u))
else:
  while m1 != 0:
      a=n1%m1
      n1=m1
      m1=a
  u = (m * n) // n1
  print('最大公约数%d\n最小公倍数%d'%(n1,u))
正确答案
def gcd(m, n):
   if m < n:
      m, n = n, m 
   while n != 0:
      temp = m % n
      m = n
      n = temp
   return m
print(gcd(24,36)) 
解析

+ 1.0 分
46 . 简答题 困难 1分
求一元二次方程ax2+bx+c=0的根，用3个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
 回答正确

a=float(input('输入 a:'))
b=float(input('输入 b:'))
c=float(input('输入 c:'))
 
if a != 0:
  delta = b**2-4*a*c
if delta < 0:
  print("无根")
elif delta == 0:
  m = -b/(2*a)
  print("x1=x2=",m)
else:
  x1= ((b+(b**2-4*a*c)**0.5)/(2*a))
  x2= ((-b+(b**2-4*a*c)**0.5)/(2*a))
  print("x1=",x1,"\t","x2=",x2)
正确答案
import math
def m(a,b,c):
   delta = b ** 2 - 4 * a *c
   root = math.sqrt(delta)
   s1 = (-b + root) / (2 * a)
   s2 = (-b - root) / (2 * a)
   print('实根为:', s1, s2)
def n(a,b,c):
   delta = (b ** 2 - 4 * a *c)*(-1)
   root = complex(0,math.sqrt(delta))
   s1 = (-b + root) / (2 * a)
   s2 = (-b - root) / (2 * a)
   print('虚根为', s1, s2) 
解析

+ 1.0 分
47 . 简答题 困难 1分
编写一个函数，求方程ax2+bx+c=0的根，用1个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
 回答正确

a=float(input('输入 a:'))
b=float(input('输入 b:'))
c=float(input('输入 c:'))
 
if a != 0:
  delta = b**2-4*a*c
if delta < 0:
  print("无根")
elif delta == 0:
  m = -b/(2*a)
  print("x1=x2=",m)
else:
  x1= ((b+(b**2-4*a*c)**0.5)/(2*a))
  x2= ((-b+(b**2-4*a*c)**0.5)/(2*a))
  print("x1=",x1,"\t","x2=",x2)
正确答案
import math
def solve(a,b,c):
    if a == 0:
        return –c/b;
    else:
        if b*b-4*a*c < 0:
            x1=complex((-b)/(2*a),math.sqrt(abs((b*b-4*a*c))))
            x2=complex((-b)/(2*a),-math.sqrt(abs((b*b-4*a*c))))
        elif b*b-4*a*c == 0:
            x1=(-b)/(2*a)
            x2=(-b)/(2*a)
        elif b*b-4*a*c > 0:
            x1=(-b+math.sqrt(b*b-4*a*c))/(2*a)
            x2=(-b-math.sqrt(b*b-4*a*c))/(2*a)
return (x1,x2)
x = int(input("请输入a:"))
y = int(input("请输入b:"))
z = int(input("请输入c:"))
print("求解：",solve(x,y,z)) 
解析

+ 1.0 分
48 . 简答题 困难 1分
编写一个函数，调用该函数能够打印一个由指定字符组成的n行金字塔。其中，指定打印的字符和行数n分别由两个形参表示。
 回答正确

def fun(c,n):
  m = n-1
  for i in range(1,n+1):
    print(" "*m,end='')
    print(c*(2*i-1))
    m = m-1
  return
c = str(input("请输入字符:"))
n = int(input("请输入行数:"))
fun(c,n)
正确答案
def jinzita(n):
    for i in range(1,n): #[1,2,3,4,...n-1]
        print(''*(20-(i-1))+'*'*(2*i-1))
#主程序
a= int (input("输入打印行数："))
jinzita(a+1) 
解析

+ 1.0 分
49 . 简答题 困难 1分
编写一个判断n是完数的函数，
 回答正确

sum =0
for i in range(1,28):    
    if 28 % i == 0:
        sum += i
if sum ==28:                        
    print ('28是完数')
else:
    print('28不是完数'）
正确答案
def judge(n):
    sum=0
    for i in range(1,n):
        if n%i == 0:
            sum += i
    if sum == n:
        print(n,"是完数！")
    else:
        print(n,"不是完数！") 
解析

+ 1.0 分
50 . 简答题 困难 1分
十进制转二进制
 回答正确

number = int(input())
binnum = bin(number)
print(binnum)
正确答案
def binary(n):
    list = []
    while n//2 != 0:
        list.append(n%2)
        n = n // 2
        if n//2 == 0:
            list.append(n%2)
            break
    list.reverse()
    for t in list:
        print(t,end='')
    print() 
解析

+ 1.0 分
51 . 简答题 中等 1分
实现回文字符串
 回答正确

def is_palindromic(num):
  str_len = len(num)
  index = str_len // 2
  str1 = num[:index]
  str2 = num[index:][::-1]
  if str1 == str2:
    return True
  else:
    return False
正确答案
def huiwen(e):
    x=0
    y=len(e)-1
while x<y:
if(e[x] != e[y]):
break
        x+=1
y-=1
if(x<y):
flag=0
else:
flag=1
return flag
e=input("请输入一串字符\n")
if(huiwen(e)):
    print("这是回文字符串\n")
else:
print("这不是回文字符串\n") 
解析

+ 1.0 分
52 . 简答题 中等 1分
统计字符串中有多少个单词
 回答正确

str1='The qulck brown for jumps over the lazy dog.'
t=0
for i in str1:
  if i in ' ':
    t=t+1
t=t+1
print(f"单词的个数为：{t}")
正确答案
def geshu(e):
    a=e.split(' ')
return len(a)
e=input("请输入一句话\n")
print("这句话中有%d个单词"%geshu(e)) 
解析

+ 1.0 分
53 . 简答题 困难 1分
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
 回答正确

def start():
  print("a.判断是否为素数")
  print("b.查询所有三位数的素数")
  print("c.退出程序")
  H=input("请输入选项:")
  if H=='a':
    a()
  elif H=='b':
    b()
  elif H=='c':
    exit   
  else:
    print("输入错误，请重新输入")
    start()
def a():
  num = eval(input("输入你要判断的数："))
  for i in range(2, num//2):
    if num % i == 0:
      print("%d不是一个素数" % num)
      break
  else:
    print("%d是一个素数" % num)
  start()
def b():
  num = []
  x = 2
  for x in range(100, 1001):
    y = 2
    for y in range(2, x):
      if x%y == 0:
        break
    else:
      num.append(x)
  print(num)
  start()
start()
正确答案
import math
def IsPrime(Num):
    if Num ==1:
        return False
    for i in range(2,int(math.sqrt(Num))+1):
        if Num%i==0:
            return False
    return True
oList = []
for i in range(100,999+1):
    if IsPrime(i)==True:
        oList.append(i)
print(oList) 
解析

+ 1.0 分
54 . 简答题 中等 1分
编写一个函数，将华氏温度转换为摄氏温度。公式为C=(F-32)×5/9。
 回答正确

F=eval(input())
C=5/9*(F-32)
print('华氏温度{}转换为摄氏温度为{:.2f}'.format(F,C))
正确答案
def m(a):
  return (a-32)*5/9
a=int(input('输入华氏温度'))
c=m(a)
print(c)
解析

+ 1.0 分
55 . 简答题 中等 1分
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
 回答正确

def start():
  print("a.判断是否为素数")
  print("b.查询所有三位数的素数")
  print("c.退出程序")
  H=input("请输入选项:")
  if H=='a':
    a()
  elif H=='b':
    b()
  elif H=='c':
    exit   
  else:
    print("输入错误，请重新输入")
    start()
def a():
  num = eval(input("输入你要判断的数："))
  for i in range(2, num//2):
    if num % i == 0:
      print("%d不是一个素数" % num)
      break
  else:
    print("%d是一个素数" % num)
  start()
def b():
  num = []
  x = 2
  for x in range(100, 1001):
    y = 2
    for y in range(2, x):
      if x%y == 0:
        break
    else:
      num.append(x)
  print(num)
  start()
start()
正确答案
import math
def IsPrime(Num):
    if Num ==1:
        return False
    for i in range(2,int(math.sqrt(Num))+1):
        if Num%i==0:
            return False
return True
oList = []
for i in range(100,999+1):
    if IsPrime(i)==True:
        oList.append(i)
print(oList)
解析

+ 1.0 分
56 . 简答题 中等 1分
编写一个函数，求满足以下条件的最大的n值：（答案13）
    12+22+32+42+…+n2<1000
 回答正确

i,s=1,0
while s+i*i<=1000:
  s+=i*i
  i+=1
print("%d is max value wehn s<=1000,s=%d"%(i,s))
正确答案
非递归实现
def s():
   sum=0
   n=0
   while sum<1000:
      n=n+1
      sum=sum+n*n     
      
   return n-1
print(s())
递归实现：
def s(sum,n):
   if sum>=1000:
       return n-1
   else:
      n=n+1
      sum=sum+n*n      
      return s(sum,n)
sum=0
n=0
print(s(sum,n))
验证：
sum=0
for i in range(1,15):
   sum=sum+i*i
   print(i,sum)
1 1
2 5
3 14
4 30
5 55
6 91
7 140
8 204
9 285
10 385
11 506
12 650
13 819
14 1015
解析

+ 1.0 分
57 . 简答题 中等 1分
反序输出输入的5个字符。
 回答正确

def output(s,l):
  if l==0:
    return
  print(s[l-1])
  output(s,l-1)
s=input("Input a string: ")
l=len(s)
output(s,l)
正确答案
#对于str类型，python并没有reverse函数。然而，通过反向步进切片，我们可以高效地反转一串字符串。
def revser(s):
   return s[::-1]   
print(revser("abcde"))
解析

+ 1.0 分
58 . 简答题 中等 1分
编写一递归函数将所输入的5个字符按相反的顺序排列出来。（递归）
 回答正确

def f(s,length):
    if length < 0:
        return ''
    else :
        return s[length]+f(s,length-1)
 
s=input("请输入一个字符串:")
length=len(s)-1
print(f(s,length))
正确答案
def shuru(n):
   if n==0:
      return 
   c=input()  #仅输入1个字符
   shuru(n-1)
   print(c)
shuru(5)
解析

+ 1.0 分
59 . 简答题 中等 1分
编写一个函数multi()，参数个数不限，返回所有参数的乘积。
 回答正确

def multi():
  try:
    str=input("输入要计算的参数，用空格隔开")
    c=1
    for item in str.split():
    #通过for循环可根据特定符号简洁分割字符串，split（）无参默认根据空格切割
      c=c*int(item)#切割出来的是字符串，需强转成int型，便于运算
    print(c)
  except:
    print("error")
multi()
正确答案
def multi(*num):
   sum=1    
   for i in num :       
      sum=sum*i     
   return sum
print(multi(2,3,4))
解析

+ 1.0 分
60 . 简答题 中等 1分
编写一个函数，功能是求两个正整数m和n的最大公约数。
 回答正确

m=m1=eval(input('请输入第一个正整数：'))
n=n1=eval(input('请输入第二个正整数：'))
if m1>=n1:            #判断m和n哪个为较大的数
  while n1 !=0 :        #较小的数为0时，返回的大数即为最大公约数
      a=m1%n1   
      m1=n1         #将小数作为下一轮循环的大数
      n1=a         #将大数除于小数得到的的余数作为下一轮循环的小数
  u = (m * n) // m1 #最小公倍数为两数之积除以最大公约数
  print('最大公约数%d\n最小公倍数%d'%(m1,u))
else:
  while m1 != 0:
      a=n1%m1
      n1=m1
      m1=a
  u = (m * n) // n1
  print('最大公约数%d\n最小公倍数%d'%(n1,u))
正确答案
def gcd(m, n):
   if m < n:
      m, n = n, m 
   while n != 0:
      temp = m % n
      m = n
      n = temp
   return m
print(gcd(24,36))
解析

+ 1.0 分
61 . 简答题 中等 1分
求一元二次方程ax2+bx+c=0的根，用3个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
 回答正确

a=float(input('输入 a:'))
b=float(input('输入 b:'))
c=float(input('输入 c:'))
 
if a != 0:
  delta = b**2-4*a*c
if delta < 0:
  print("无根")
elif delta == 0:
  m = -b/(2*a)
  print("x1=x2=",m)
else:
  x1= ((b+(b**2-4*a*c)**0.5)/(2*a))
  x2= ((-b+(b**2-4*a*c)**0.5)/(2*a))
  print("x1=",x1,"\t","x2=",x2)
正确答案
import math
def m(a,b,c):
   delta = b ** 2 - 4 * a *c
   root = math.sqrt(delta)
   s1 = (-b + root) / (2 * a)
   s2 = (-b - root) / (2 * a)
   print('实根为:', s1, s2)
def n(a,b,c):
   delta = (b ** 2 - 4 * a *c)*(-1)
   root = complex(0,math.sqrt(delta))
   s1 = (-b + root) / (2 * a)
   s2 = (-b - root) / (2 * a)
   print('虚根为', s1, s2)
a = float(input('输入 a :'))
b = float(input('输入 b :'))
c = float(input('输入 c :'))
if a == 0:
    s = -c/b
    print('实根为:', s)
else:
    delta = b ** 2 - 4 * a *c
    if delta == 0:
        s = -b/(2 * a)
        print('实根为:', s)
    elif delta < 0:
        n(a,b,c)
    else:
        m(a,b,c)
解析

+ 1.0 分
62 . 简答题 中等 1分
编写一个函数，求方程ax2+bx+c=0的根，用1个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
 回答正确

a=float(input('输入 a:'))
b=float(input('输入 b:'))
c=float(input('输入 c:'))
 
if a != 0:
  delta = b**2-4*a*c
if delta < 0:
  print("无根")
elif delta == 0:
  m = -b/(2*a)
  print("x1=x2=",m)
else:
  x1= ((b+(b**2-4*a*c)**0.5)/(2*a))
  x2= ((-b+(b**2-4*a*c)**0.5)/(2*a))
  print("x1=",x1,"\t","x2=",x2)
正确答案
import math
def solve(a,b,c):
    if a == 0:
        return –c/b;
    else:
        if b*b-4*a*c < 0:
            x1=complex((-b)/(2*a),math.sqrt(abs((b*b-4*a*c))))
            x2=complex((-b)/(2*a),-math.sqrt(abs((b*b-4*a*c))))
        elif b*b-4*a*c == 0:
            x1=(-b)/(2*a)
            x2=(-b)/(2*a)
        elif b*b-4*a*c > 0:
            x1=(-b+math.sqrt(b*b-4*a*c))/(2*a)
            x2=(-b-math.sqrt(b*b-4*a*c))/(2*a)
         return (x1,x2)
x = int(input("请输入a:"))
y = int(input("请输入b:"))
z = int(input("请输入c:"))
print("求解：",solve(x,y,z))
解析

+ 1.0 分
63 . 简答题 中等 1分
编写一个函数，调用该函数能够打印一个由指定字符组成的n行金字塔。其中，指定打印的字符和行数n分别由两个形参表示。
 回答正确

def fun(c,n):
  m = n-1
  for i in range(1,n+1):
    print(" "*m,end='')
    print(c*(2*i-1))
    m = m-1
  return
c = str(input("请输入字符:"))
n = int(input("请输入行数:"))
fun(c,n)
正确答案
def jinzita(n):
    for i in range(1,n):    #[1,2,3,4,...n-1]
        print(' '*(20-(i-1))+'*'*(2*i-1))
#主程序 
a= int (input("输入打印行数："))
jinzita(a+1)
解析

+ 1.0 分
64 . 简答题 中等 1分
判断完数
 回答正确

sum =0
for i in range(1,28):    
    if 28 % i == 0:
        sum += i
if sum ==28:                        
    print ('28是完数')
else:
    print('28不是完数'）
正确答案
def judge(n):
    sum=0
    for i in range(1,n):
        if n%i == 0:
            sum += i
    if sum == n:
        print(n,"是完数！")
    else:
        print(n,"不是完数！")
if __name__ == "__main__":
    n = int(input("请输入一个数："))
    judge(n)
解析

+ 1.0 分
65 . 简答题 中等 1分
十进制转二进制
 回答正确

number = int(input())
binnum = bin(number)
print(binnum)
正确答案
def binary(n):
    list = []
    while n//2 != 0:
        list.append(n%2)
        n = n // 2
        if n//2 == 0:
            list.append(n%2)
            break
    list.reverse()
    for t in list:
        print(t,end='')
    print()
if __name__ == "__main__":
    n = int(input("请输入一个数："))
    binary(n)
解析

+ 1.0 分
66 . 简答题 中等 1分
回文字符串
 回答正确

def is_palindromic(num):
  str_len = len(num)
  index = str_len // 2
  str1 = num[:index]
  str2 = num[index:][::-1]
  if str1 == str2:
    return True
  else:
    return False
正确答案
def huiwen(e):
    x=0
    y=len(e)-1
    while x
解析

+ 1.0 分
67 . 简答题 中等 1分
字符串中有多少个单词
 回答正确

str1='The qulck brown for jumps over the lazy dog.'
t=0
for i in str1:
  if i in ' ':
    t=t+1
t=t+1
print(f"单词的个数为：{t}")
正确答案
def geshu(e):
    a=e.split(' ')
    return len(a)
e=input("请输入一句话\n")
print("这句话中有%d个单词"%geshu(e))
解析

平时作业4-第5章
1 . 单选题 简单 2分
调用open函数可以打开指定文件，在open（）函数中访问模式参数使用（  ）表示只读。
A.
a
B.
w+
C.
r
D.
w
 回答正确

C
正确答案
C
解析

+ 2.0 分
2 . 单选题 简单 2分
下列哪项不是Python中对文件的读取操作：
A.
read
B.
readall
C.
readlines
D.
readline
 回答正确

B
正确答案
B
解析

+ 2.0 分
3 . 单选题 简单 2分
在读写文件之前，必须通过以下哪个方法创建文件对象：
A.
create
B.
folder
C.
File
D.
open
 回答正确

D
正确答案
D
解析

+ 0.0 分
4 . 单选题 简单 2分
以下不能创建一个字典的语句是：
A.
dict = {}
B.
dict = {(4,5,6):'dictionary'}
C.
dict= {4：6}
D.
dict = {[4,5,6]:'dictionary'}
 回答错误

C
正确答案
D
解析

+ 2.0 分
5 . 单选题 简单 2分
以下描述中错误的是哪一项？
A.
字符串的格式化，'{:.2f}'.format(math.pi) 与 '%.2f' % math.pi 在运算结果上相同。
B.
Python中的同一种序列互相之间可以进行比较，按照字典序进行排序，例如 (1, 2, 3, 4) < (1, 2, 4) 的运算结果是True。
C.
打开一个文本文件，f = open('test.txt', 'r+'); 则 f.seek(5) 表示在打开的文件里寻找数字5。
D.
打开一个文本文件，在对其进行读取，f = open('test.txt', 'r+'); f.read() ;read函数内不带参数是读取整个文本文件内容并返回
 回答正确

C
正确答案
C
解析

+ 0.0 分
6 . 单选题 简单 2分
以下不能作为字典的key的是哪一个选项？
A.
num
B.
listA =
C.
123
D.
tupleA = ('sum')
 回答错误

B
正确答案
C
解析

+ 1.0 分
7 . 简答题 困难 2分
编写程序，打开任意的文本文件，读出其中内容，判断该文件中某些给定关键字如“中国”出现的次数。
 回答正确

def count_keyword_occurrences(filename, keyword):
  count = 0
  with open(filename, 'r', encoding='utf-8') as file:
    content = file.read()
    count = content.count(keyword)
  return count
# 要统计的关键字和文件路径
keyword = '中国'
filename = 'example.txt'
# 统计关键字出现的次数
occurrences = count_keyword_occurrences(filename, keyword)
# 显示结果
print(f'关键字"{keyword}"在文件"{filename}"中出现了{occurrences}次。')
正确答案
n=0
#hellofile=open("d:\\152\\612.txt")
filename = input("please input filename")
hellofile=open("d:\\152\\"+filename)
filecontent=hellofile.readlines()
hellofile.close()
print(filecontent)  #['中国\n', '美国\n', '中国人民\n', '日本\n', '中国人']
for s in filecontent:
    n=n+s.count("中国")            
print(n)
 
解析

+ 1.0 分
8 . 简答题 困难 2分
编写程序，打开任意的文本文件，在指定的位置产生一个相同文件的副本，即实现文件的拷贝功能。
 回答正确

def copy_file(source_filename, target_filename):
  with open(source_filename, 'r', encoding='utf-8') as source_file:
    with open(target_filename, 'w', encoding='utf-8') as target_file:
      content = source_file.read()
      target_file.write(content)
  print(f'文件"{source_filename}"已成功拷贝到"{target_filename}"。')
# 原始文件和目标文件路径
source_filename = 'source.txt'
target_filename = 'target.txt'
# 执行文件拷贝
copy_file(source_filename, target_filename)
正确答案
#方法一：
def copy_file(oldfile,newfile):
    oldFile=open(oldfile,"r")
    newFile=open(newfile,"w")
    while True:
        filecontent=oldFile.read(50)
        if  filecontent=="":
            break
        newFile.write(filecontent)
    oldFile.close()
    newFile.close()
    return
#主程序
copy_file("d:\\152\\612.txt","d:\\152\\615.txt")
#方法二：
import shutil
shutil.copyfile("d:\\152\\612.txt","d:\\152\\615.txt")
#方法三：
def main():  
# 用户输入文件名
    f1 = input("Enter a soucefile:").strip()  
    f2 = input("Enter a soucefile:").strip()  
    # 打开文件
    infile = open(f1,"r")  
    outfile = open(f2,"w")  
 # 拷贝数据
    countLines = countChars = 0  
    for line in infile:  
        countLines += 1  
        countChars += len(line)  
        outfile.write(line)  
    print(countLines,"linesand",countChars,"chars copied")  
    infile.close()  
    outfile.close()  
main()
【运行结果】
Enter a soucefile:s.txt
Enter a soucefile:q.txt
46 lines and 1500chars copied
 
解析

+ 1.0 分
9 . 简答题 中等 2分
用Windows“记事本”创建一个文本文件，其中每行包含一段英文。试读出文件的全部内容，并判断：
（1）该文本文件共有多少行？
（2）文件中以大写字母P开头的有多少行？
（3）一行中包含字符最多的和包含字符最少的分别在第几行？
 回答正确

def analyze_text_file(filename):
  line_count = 0
  starts_with_p_count = 0
  max_length_line = ''
  min_length_line = ''
  max_length = 0
  min_length = float('inf')
  with open(filename, 'r', encoding='utf-8') as file:
    lines = file.readlines()
    line_count = len(lines)
    for i, line in enumerate(lines, start=1):
      if line.startswith('P'):
        starts_with_p_count += 1
      line_length = len(line.strip())
      if line_length > max_length:
        max_length = line_length
        max_length_line = line
        max_length_line_num = i
      if line_length < min_length:
        min_length = line_length
        min_length_line = line
        min_length_line_num = i
  print(f'该文本文件共有{line_count}行。')
  print(f'文件中以大写字母P开头的行数为{starts_with_p_count}行。')
  print(f'一行中包含字符最多的行在第{max_length_line_num}行。')
  print(f'一行中包含字符最少的行在第{min_length_line_num}行。')
  print('\n文件的全部内容：')
  print('-------------------')
  for line in lines:
    print(line.strip())
  print('-------------------')
# 要读取的文本文件路径
filename = 'example.txt'
# 执行分析和输出
analyze_text_file(filename)
正确答案
（1）
file1=open("d:\\152\\test.txt")
filecontent=file1.readlines()   #列表
file1.close()
a=len(filecontent)
print(a)
（2）
>>> s="pig"
>>> s.startswith('p')
True
>>> s="hello"
>>> s.startswith('p')
False
file1=open("d:\\test.txt")
filecontent=file1.readlines()   #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=0
for s in filecontent:
    if s.startswith('P')==True:
        print(s)
        n+=1
print("以大写字母P开头的有",n,"行")
  （3）
file1=open("d:\\test.txt")
filecontent=file1.readlines()   #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=1
maxnum=0
for s in filecontent:
    k=len(s)
    if k>maxnum:
        maxnum=k
        pos=n
    n+=1    
print("一行中包含字符最多的是",pos,"行")
print("一行字符最多的是",maxnum)
 
解析

+ 1.0 分
10 . 简答题 中等 2分
编写程序，打开任意的文本文件，读出其中内容，判断该文件中某些给定关键字如“中国”出现的次数。
 回答正确

def count_keywords(filename, keywords):
  keyword_counts = {}
  with open(filename, 'r', encoding='utf-8') as file:
    content = file.read()
    for keyword in keywords:
      count = content.count(keyword)
      keyword_counts[keyword] = count
  return keyword_counts
# 要读取的文本文件路径
filename = 'example.txt'
# 要检查的关键字列表
keywords = ['中国', '文化', '发展']
# 执行统计
result = count_keywords(filename, keywords)
# 输出结果
for keyword, count in result.items():
  print(f'关键字"{keyword}"在文本中出现了{count}次。')
正确答案
n=0
#hellofile=open("d:\\152\\612.txt") 
filename = input("please input filename")
hellofile=open("d:\\152\\"+filename)
filecontent=hellofile.readlines()
hellofile.close()
print(filecontent)  #['中国\n', '美国\n', '中国人民\n', '日本\n', '中国人']
for s in filecontent:
    n=n+s.count("中国")            
print(n)
解析

+ 1.0 分
11 . 简答题 中等 2分
编写程序，打开任意的文本文件，在指定的位置产生一个相同文件的副本，即实现文件的拷贝功能。
 回答正确

import shutil
def copy_file(source, destination):
  shutil.copy2(source, destination)
# 要拷贝的源文件路径
source_file = 'source.txt'
# 目标文件路径，即拷贝后的副本文件路径
destination_file = 'destination.txt'
# 执行拷贝
copy_file(source_file, destination_file)
print('文件拷贝完成。')
正确答案
方法一：
def copy_file(oldfile,newfile):
    oldFile=open(oldfile,"r")
    newFile=open(newfile,"w")
    while True:
        filecontent=oldFile.read(50)
        if  filecontent=="":
            break
        newFile.write(filecontent)
    oldFile.close()
    newFile.close()
    return
#主程序
copy_file("d:\\152\\612.txt","d:\\152\\615.txt")
方法二：
import shutil
shutil.copyfile("d:\\152\\612.txt","d:\\152\\615.txt")
方法三：
def main():  
# 用户输入文件名  
    f1 = input("Enter a soucefile:").strip()  
    f2 = input("Enter a soucefile:").strip()  
   
    # 打开文件  
    infile = open(f1,"r")  
    outfile = open(f2,"w")  
    # 拷贝数据  
    countLines = countChars = 0  
    for line in infile:  
        countLines += 1  
        countChars += len(line)  
        outfile.write(line)  
    print(countLines,"lines and",countChars,"chars copied")  
   
    infile.close()  
    outfile.close()  
main()
【运行结果】
Enter a soucefile:s.txt
Enter a soucefile:q.txt
46 lines and 1500chars copied
解析

+ 1.0 分
12 . 简答题 中等 2分
用Windows“记事本”创建一个文本文件，其中每行包含一段英文。试读出文件的全部内容，并判断：
（1）该文本文件共有多少行？
（2）文件中以大写字母P开头的有多少行？
（3）一行中包含字符最多的和包含字符最少的分别在第几行？
 回答正确

def read_file(file_path):
  lines = []
  max_length_line = ''
  min_length_line = ''
  line_count = 0
  p_start_line_count = 0
  with open(file_path, 'r', encoding='utf-8') as file:
    for line in file:
      line = line.strip()
      lines.append(line)
      line_count += 1
      if line.startswith('P'):
        p_start_line_count += 1
      if len(line) > len(max_length_line):
        max_length_line = line
      if not min_length_line or len(line) < len(min_length_line):
        min_length_line = line
  return lines, line_count, p_start_line_count, max_length_line, min_length_line
# 要读取的文本文件路径
file_path = 'example.txt'
# 执行读取文件
lines, line_count, p_start_line_count, max_length_line, min_length_line = read_file(file_path)
# 输出结果
print(f'该文本文件共有{line_count}行。')
print(f'文件中以大写字母P开头的行共有{p_start_line_count}行。')
print(f'一行中包含字符最多的在第{lines.index(max_length_line) + 1}行。')
print(f'一行中包含字符最少的在第{lines.index(min_length_line) + 1}行。')
正确答案
（1）
file1=open("d:\\152\\test.txt")
filecontent=file1.readlines()   #列表
file1.close()
a=len(filecontent)
print(a)
（2）
>>> s="pig"
>>> s.startswith('p')
True
>>> s="hello"
>>> s.startswith('p')
False
file1=open("d:\\test.txt")
filecontent=file1.readlines()   #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=0
for s in filecontent:
    if s.startswith('P')==True:
        print(s)
        n+=1
print("以大写字母P开头的有",n,"行")
（3）
file1=open("d:\\test.txt")
filecontent=file1.readlines()   #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=1
maxnum=0
for s in filecontent:
    k=len(s)
    if k>maxnum:
        maxnum=k
        pos=n
    n+=1    
        
print("一行中包含字符最多的是",pos,"行")
print("一行字符最多的是",maxnum)
解析

+ 2.0 分
13 . 单选题 简单 2分
以下关于Python文件的描述，错误的选项是_________。
A.
二进制文件和文本文件的操作步骤都是“打开-操作-关闭”
B.
在open()打开文件之后，文件的内容并没有在内存中
C.
open()只能打开一个已经存在的文件
D.
在文件读写之后，需要调用close()才能确保文件被保存在磁盘中
 回答正确

C
正确答案
C
解析

+ 2.0 分
14 . 单选题 简单 2分
以下关于Python中CSV文件的描述，错误的选项是_________。
A.
CSV文件可用于不同工具间进行数据交换
B.
CSV文件格式是一种通用的、相对简单的文件格式，应用于程序之间转移表格数据
C.
CSV文件通过多种编码表示字符
D.
CSV文件的每一行是一维数据，可以使用Python中的列表数据类型表示
 回答正确

C
正确答案
C
解析

+ 2.0 分
15 . 单选题 简单 2分
以下关于Python文件‘+’打开模式的描述，正确的选项是_________。
A.
追加写模式
B.
与r/w/a/x一同使用，在原功能基础上增加同时读写功能
C.
只读模式
D.
覆盖写模式
 回答正确

B
正确答案
B
解析

+ 2.0 分
16 . 单选题 简单 2分
以下关于Python文件的描述，错误的选项是_________。
A.
readlines()函数读入文件内容后返回一个列表，元素划分依据是文本文件中的换行符
B.
read()函数一次性读入文本文件的全部内容后，返回一个字符串
C.
readline()函数读入文本文件的一行，返回一个字符串
D.
二进制文件和文本文件都是可以用文本编辑器编辑的文件
 回答正确

D
正确答案
D
解析

+ 2.0 分
17 . 单选题 简单 2分
以下关于Python文件的描述，错误的选项是_________。
A.
open()函数的参数处理模式‘b’表示以二进制数据处理文件
B.
open()函数的参数处理模式‘+’表示可以对文件进行读和写操作
C.
readline()函数表示读取文件的下一行，返回一个字符串
D.
open()函数的参数处理模式‘a’表示以追加方式打开文件，删除已有内容
 回答正确

D
正确答案
D
解析

+ 2.0 分
18 . 单选题 简单 2分
Python文件读取方法read(size)的含义是_________。
A.
从头到尾读取文件所有内容
B.
从文件中读取一行数据
C.
从文件中读取多行数据
D.
从文件中读取指定size大小的数据，如果size为负数或者空，则读取到文件结束
 回答正确

D
正确答案
D
解析

+ 2.0 分
19 . 填空题 简单 2分
Python语句print(1,2,3,4,5,sep='-',end='!')的输出结果是____________。
 回答正确

1-2-3-4-5!
正确答案
1-2-3-4-5!
解析
print()函数用于打印一行内容，即将多个以分隔符（sep，默认为空格）分隔的值（value，...，以逗号分隔的值），写入到指定文件流（file，默认为控制台sys.stdout）。参数end指定换行符；flush指定是否强制写入到流

+ 2.0 分
20 . 填空题 简单 2分
Python语句“for i in range(5): print(i, end=' ')”的输出结果是___ ______、_________、_________、_________、_________。
 回答正确

无、1、2、3、4
正确答案
0、1、2、3、4
解析
print()函数用于打印一行内容，即将多个以分隔符（sep，默认为空格）分隔的值（value，...，以逗号分隔的值），写入到指定文件流（file，默认为控制台sys.stdout）。参数end指定换行符；flush指定是否强制写入到流。

+ 2.0 分
21 . 填空题 简单 2分
在Python程序中，可以通过列表___________访问命令行参数。___________为Python脚本名，___________为第一个参数名，___________为第二个参数名。
 回答正确

sys.argv、argv[0]、argv[1]、argv[2]
正确答案
sys.argv、argv[0]、argv[1]、argv[2]
解析
程序中可以通过列表sys.argv访问命令行参数。argv[0]为Python脚本名，argv[1]为第一个参数，argv[2]为第二个参数，依此类推。

+ 2.0 分
22 . 填空题 简单 2分
Python程序使用___________模块解析命名的命令行参数。
（注意：英文区分大小写）
 回答正确

argparse
正确答案
argparse
解析
argparse模块是用于解析命名的命令行参数，生成帮助信息的python标准模块。

+ 2.0 分
23 . 填空题 简单 2分
如果在程序运行时，需要提示用户输入密码，则可以使用模块___________，以保证用户输入的密码在控制台中不回显。（注意：英文区分大小写）
 回答正确

getpass
正确答案
getpass
解析
如果在程序运行时，需要提示用户输入密码，则可以使用模块getpass，以保证用户输入的密码在控制台中不回显。

+ 2.0 分
24 . 填空题 简单 2分
Python语言使用___________语句实现上下文管理协议。（注意：英文区分大小写）
 回答正确

with
正确答案
with
解析
文件对象支持使用with语句，确保打开的文件自动关闭。

+ 2.0 分
25 . 填空题 简单 2分
Python语言中，使用sys模块中的___________、___________和___________，可以查看对应的标准输入、标准输出和标准错误流文件对象。（注意：英文区分大小写）
 回答正确

sys.stdin、sys.stdout、sys.stderr
正确答案
sys.stdin、sys.stdout、sys.stderr
解析
（1）使用sys模块的sys.stdin、sys.stdout和sys.stderr，可以查看对应的标准输入、标准输出和标准错误流文件对象。（2）标准输入流文件对象默认对应于控制台键盘。标准输出流文件对象和错误输出流文件对象默认对应于控制台，其区别仅在于后者是非缓冲的。

+ 0.0 分
26 . 填空题 简单 2分
Python可以使用函数____________打开文件。（注意：英文区分大小写）
 回答错误

open()
正确答案
open
解析
使用open()函数打开或创建一个文件时，其默认的打开模式为只读文本文件。文本文件用于储存文本字符串，默认编码为Unicode。

+ 0.0 分
27 . 填空题 简单 2分
文件操作可以使用_________方法关闭流，以释放资源。通常采用_________语句，以保证系统自动关闭打开的流。（注意：英文区分大小写）
 回答错误

with、close
正确答案
close、with
解析
写入文件完成后，应该使用close方法关闭流，以释放资源，并把缓冲的数据更新到文件中。

+ 2.0 分
28 . 填空题 简单 2分
打开随机文件后，可以使用实例方法____________进行定位。（注意：英文区分大小写）
 回答正确

seek
正确答案
seek
解析
文件对象支持seek方法，seek通过字节偏移量将读取/写入位置移动到文件中的任意位置，从而实现文件的随机访问。

+ 2.0 分
29 . 填空题 简单 2分
____________模块提供处理用于循环处理输入、输入重定向、管道或一个或多个文本文件的函数和辅助对象。（注意：英文区分大小写）
 回答正确

fileinput
正确答案
fileinput
解析
无。

+ 2.0 分
30 . 填空题 简单 2分
可以使用____________模块中提供的函数，实现Python对象的系列化。（注意：英文区分大小写）
 回答正确

pickle
正确答案
pickle  [或者]cPickle    [或者]marshal
解析
对象序列化也称为串行化，将对象转换为数据形式，并转储到磁盘文件或通过网络实现跨平台传输。
    

+ 1.0 分
31 . 简答题 中等 2分
请编写程序生成随机密码。具体要求如下。
（1）使用random库，采用0x1010作为随机数种子。
（2）密码由26个字母大小写、10个数字字符以及“!、@、#、$、%、^、&、*”等8个特殊符号组成。
（3）每个密码长度固定为10个字符。
（4）程序运行每次产生10个密码，每个密码一行。
（5）每次产生的10个密码首字符不能一样。
（6）程序运行后产生的密码保存在“随机密码.txt”文件中。
 回答正确

import random
def generate_password():
  chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*'
  password = random.sample(chars, 9) # 随机选取9个字符
  password.insert(0, random.choice(chars[:-10])) # 在第一个位置插入一个首字符不重复的字符
  return ''.join(password)
def generate_passwords(file_path):
  random.seed(0x1010) # 使用0x1010作为随机数种子
   
  with open(file_path, 'w') as file:
    for _ in range(10): # 生成10个密码
      passwords = set()
      while len(passwords) < 10:
        password = generate_password()
        if password[0] not in passwords:
          passwords.add(password[0])
          file.write(password + '\n')
# 生成随机密码并保存到文本文件
file_path = '随机密码.txt'
generate_passwords(file_path)
正确答案
import random
random.seed(0x1010)  
s="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890! @#$%^&*"
ls=[]
excludes=" "
while len(ls)< 10:
    pwd=" "
    for i in range(10):
        pwd+=s[random.randint(0,len(s)-1)]
        if pwd[0] in excludes:
           continue
    ls.append(pwd)
    excludes+= pwd[0]
fo=open("随机密码.txt","w")
fo.write("\n".join(ls))
fo.close()
解析

+ 1.0 分
32 . 简答题 困难 2分
编写程序，实现一个简单的基于字典数据结构的通信录管理系统。系统采用JSON文件来保存数据。通信录设计为字典{name：tel}。程序开始时从addressbook.json文件中读取通信录，然后显示主菜单，具体包括如下功能：
（1）显示通讯录清单。如果通信录字典中存在用户信息，则显示通讯录清单，包括姓名和电话号码；如果通信录字典中不存在任何用户信息，则提示“通讯录为空”。
（2）查询联系人。提示用户输入姓名name，在通信录字典中查询该键，如果存在，输出联系人信息；如果不存在，提示是否新建联系人。
（3）插入新的联系人。提示用户输入姓名name，在通信录字典中查询该键，如果存在，提示是否更新联系人信息；如果不存在，提示输入电话号码，并插入字典键-值对。
（4）删除已有联系人。提示用户输入姓名name，在通信录字典中查询该键，如果不存在，输出“联系人不存在”的提示信息；如果存在，从通信录字典中删除键-值对，并输出信息。
（5）退出。保存通信录字典到addressbook.json中，退出循环。
 回答正确

import json
def load_address_book(file_path):
  try:
    with open(file_path, 'r') as file:
      address_book = json.load(file)
  except FileNotFoundError:
    address_book = {}
  return address_book
def save_address_book(address_book, file_path):
  with open(file_path, 'w') as file:
    json.dump(address_book, file)
def display_address_book(address_book):
  if len(address_book) == 0:
    print("通讯录为空")
  else:
    print("通讯录清单:")
    for name, tel in address_book.items():
      print(f"姓名: {name}\t电话号码: {tel}")
def search_contact(address_book, name):
  if name in address_book:
    print(f"联系人信息:\n姓名: {name}\t电话号码: {address_book[name]}")
  else:
    create_new = input("联系人不存在，是否创建新联系人？(y/n) ")
    if create_new.lower() == 'y':
      tel = input("请输入电话号码: ")
      address_book[name] = tel
      print("联系人已创建")
    else:
      print("操作取消")
def insert_contact(address_book, name):
  if name in address_book:
    update_info = input("联系人已存在，是否更新联系人信息？(y/n) ")
    if update_info.lower() == 'y':
      tel = input("请输入电话号码: ")
      address_book[name] = tel
      print("联系人信息已更新")
    else:
      print("操作取消")
  else:
    tel = input("请输入电话号码: ")
    address_book[name] = tel
    print("联系人已插入")
def delete_contact(address_book, name):
  if name in address_book:
    del address_book[name]
    print("联系人已删除")
  else:
    print("联系人不存在")
# 加载通讯录
file_path = 'addressbook.json'
address_book = load_address_book(file_path)
# 主菜单
while True:
  print("-------- 通讯录管理系统 --------")
  print("(1) 显示通讯录清单")
  print("(2) 查询联系人")
  print("(3) 插入新的联系人")
  print("(4) 删除已有联系人")
  print("(5) 退出系统")
  choice = input("请选择功能(1/2/3/4/5): ")
  if choice == '1':
    display_address_book(address_book)
  elif choice == '2':
    name = input("请输入姓名: ")
    search_contact(address_book, name)
  elif choice == '3':
    name = input("请输入姓名: ")
    insert_contact(address_book, name)
  elif choice == '4':
    name = input("请输入姓名: ")
    delete_contact(address_book, name)
  elif choice == '5':
    save_address_book(address_book, file_path)
    print("通讯录已保存，系统已退出")
    break
  else:
    print("无效的选择，请重新输入")
正确答案
"""简易通信录程序"""
import os, json
ab = {} #通信录保存在字典中name:tel
#从JSON文件中读取通信录
if os.path.exists("addressbook.json"):
    with open(r'addressbook.json', 'r', encoding='utf-8') as f:
        ab = json.load(f)
while True:  
    print("|---欢迎使用通讯录程序---|")  
    print("|---1：显示通讯录清单 ---|")  
    print("|---2：查询联系人资料 ---|")  
    print("|---3：插入新的联系人 ---|")  
    print("|---4：删除已有联系人 ---|")  
    print("|---0：退出 -------------|")
    choice = input('请选择功能菜单(0-4):')
    if choice == '1':
        if(len(ab)==0):
            print("通讯录为空")
        else:
            for k, v in ab.items():
                print("姓名={},联系电话={}".format(k, v))
    elif choice == '2':
        name = input("请输入联系人姓名：")
        if(name not in ab):
            ask = input("联系人不存在，是否增加用户资料(Y/N)")  
            if ask in ["Y", "y"]:  
                tel = input("请输入用户联系电话：")  
                ab[name] = tel
        else:
            print("联系人信息：{} {}".format(name, ab[name]))
    elif choice == '3':
        name=input("请输入联系人姓名：")  
        if(name in ab):  
            print("已存在联系人：{} {}".format(name, ab[name]))  
            ask = input("是否修改用户资料(Y/N)")  
            if ask in ["Y", "y"]:  
                tel = input("请输入用户联系电话：")  
                dict[name] = tel  
        else:  
            tel = input("请输入用户联系电话：")  
            ab[name] = tel                  
    elif choice == '4':
        name = input("请输入联系人姓名：")
        if(name not in ab):  
            print("联系人不存在：{}".format(name))
        else:
            tel = ab.pop(name)
            print("删除联系人：{} {}".format(name, tel))
    elif choice == '0': #保存到JSON文件并退出循环
        with open(r'addressbook.json', 'w', encoding='utf-8') as f:
            json.dump(ab, f)        
        break
解析

+ 2.0 分
33 . 编程题 中等 2分
长方形面积
 回答正确
请编写一个名为arg_parse.py的程序，解析命令行参数所输入的长和宽的值（假设默认的长为10，宽为5），计算并输出长方形的面积。

import argparse
# 创建ArgumentParser对象
parser = argparse.ArgumentParser(description='计算长方形面积')
# 添加命令行参数
parser.add_argument('--length', type=float, default=10, help='长方形的长度')
parser.add_argument('--width', type=float, default=5, help='长方形的宽度')
# 解析命令行参数
args = parser.parse_args()
# 计算长方形的面积
area = args.length * args.width
# 输出结果
print(area)
正确答案
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--length', default=10, type=int, help='长度')
parser.add_argument('--width', default=5, type=int, help='宽度')
args = parser.parse_args()
area = args.length * args.width
print(area)
解析
argparse模块是用于解析命名的命令行参数，生成帮助信息的python标准模块。

+ 2.0 分
34 . 编程题 中等 2分
正方形的周长和面积
 回答正确
请编写一个名为arg_parse2.py的程序，解析命令行参数所输入的边长的值（假设默认的边长为10），计算并输出正方形的周长和面积。

import argparse
# 创建ArgumentParser对象
parser = argparse.ArgumentParser(description='计算正方形的周长和面积')
# 添加命令行参数
parser.add_argument('--side', type=float, default=10, help='正方形的边长')
# 解析命令行参数
args = parser.parse_args()
# 计算正方形的周长和面积
perimeter = 4 * args.side
area = args.side ** 2
# 输出结果
print(perimeter,area)
正确答案
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--side', default=10, type=int, help='边长')
args=parser.parse_args()
perimeter= 4 * args.side
area = args.side * args.side
print(perimeter, area)
解析
argparse模块是用于解析命名的命令行参数，生成帮助信息的python标准模块。
    

+ 2.0 分
35 . 编程题 中等 2分
读取并显示内存文本文件的内容
 回答正确
请编写程序，利用StringIO将数据'Hello'和'Python'写入内存文本文件中，要求每写入一行数据均换行。然后，读取并显示内存文本文件的内容。

import io
# 创建内存文本文件
memory_file = io.StringIO()
# 写入数据到内存文本文件
memory_file.write('Hello\n')
memory_file.write('Python\n')
# 读取内存文本文件的内容
content = memory_file.getvalue()
# 关闭内存文本文件
memory_file.close()
# 显示内存文本文件的内容
print(content)
正确答案
from io import StringIO
f = StringIO('Hello\nPython\n')
for s in f:
    print(s.strip())
解析
StringIO实现了内存文本文件的读取操作，常用作字符串的缓存。

+ 2.0 分
36 . 编程题 中等 2分
读取并显示内存二进制文件内容
 回答正确
请编写程序，利用BytesIO将字节数据'程序设计'写入内存二进制文件中，要求每写入一行数据均换行。然后，读取并显示内存二进制文件的内容。

import io
# 创建内存二进制文件
memory_file = io.BytesIO()
# 写入数据到内存二进制文件
data = b'\xe7\xa8\x8b\xe5\xba\x8f\xe8\xae\xbe\xe8\xae\xa1'
memory_file.write(data)
# 读取内存二进制文件的内容
content = memory_file.getvalue()
# 关闭内存二进制文件
memory_file.close()
# 显示内存二进制文件的内容
print(content)
print(content)
正确答案
from io import BytesIO
f = BytesIO()
f.write('程序设计'.encode('utf-8'))
f.seek(0)            #定位到开始位置
b=f.read()           #读取文件内容
print(b)             #显示文件内容
print(f.getvalue())    #显示文件内容
解析
BytesIO实现了内存二进制文件的读取操作，常用作字节码的缓存。

+ 2.0 分
37 . 单选题 简单 2分
以下关于Python文件的描述，错误的选项是_________。
A.
二进制文件和文本文件的操作步骤都是“打开-操作-关闭”
B.
在open()打开文件之后，文件的内容并没有在内存中
C.
open()只能打开一个已经存在的文件
D.
在文件读写之后，需要调用close()才能确保文件被保存在磁盘中
 回答正确

C
正确答案
C
解析

+ 2.0 分
38 . 单选题 简单 2分
以下关于Python中CSV文件的描述，错误的选项是_________。
A.
CSV文件可用于不同工具间进行数据交换
B.
CSV文件格式是一种通用的、相对简单的文件格式，应用于程序之间转移表格数据
C.
CSV文件通过多种编码表示字符
D.
CSV文件的每一行是一维数据，可以使用Python中的列表数据类型表示
 回答正确

C
正确答案
C
解析

+ 2.0 分
39 . 单选题 简单 2分
以下关于Python文件‘+’打开模式的描述，正确的选项是_________。
A.
追加写模式
B.
与r/w/a/x一同使用，在原功能基础上增加同时读写功能
C.
只读模式
D.
覆盖写模式
 回答正确

B
正确答案
B
解析

+ 2.0 分
40 . 单选题 简单 2分
以下关于Python文件的描述，错误的选项是_________。
A.
readlines()函数读入文件内容后返回一个列表，元素划分依据是文本文件中的换行符
B.
read()函数一次性读入文本文件的全部内容后，返回一个字符串
C.
readline()函数读入文本文件的一行，返回一个字符串
D.
二进制文件和文本文件都是可以用文本编辑器编辑的文件
 回答正确

D
正确答案
D
解析

+ 2.0 分
41 . 单选题 简单 2分
以下关于Python文件的描述，错误的选项是_________。
A.
open()函数的参数处理模式‘b’表示以二进制数据处理文件
B.
open()函数的参数处理模式‘+’表示可以对文件进行读和写操作
C.
readline()函数表示读取文件的下一行，返回一个字符串
D.
open()函数的参数处理模式‘a’表示以追加方式打开文件，删除已有内容
 回答正确

D
正确答案
D
解析

+ 2.0 分
42 . 单选题 简单 2分
Python文件读取方法read(size)的含义是_________。
A.
从头到尾读取文件所有内容
B.
从文件中读取一行数据
C.
从文件中读取多行数据
D.
从文件中读取指定size大小的数据，如果size为负数或者空，则读取到文件结束
 回答正确

D
正确答案
D
解析

+ 2.0 分
43 . 填空题 简单 2分
Python语句print(1,2,3,4,5,sep='-',end='!')的输出结果是___。
 回答正确

1-2-3-4-5!
正确答案
1-2-3-4-5!
解析

+ 2.0 分
44 . 填空题 简单 2分
Python语句“for i in range(10): print(i, end=' ')”的输出结果是____。
 回答正确

0 1 2 3 4 5 6 7 8 9
正确答案
0 1 2 3 4 5 6 7 8 9
解析

+ 2.0 分
45 . 填空题 简单 2分
在Python程序中可以通过列表___访问命令行参数。____为Python脚本名，____为第一个参数名，_____为第二个参数名。
 回答正确

sys.argv、argv[0]、argv[1]、argv[2]
正确答案
sys.argv、argv[0]、argv[1]、argv[2]
解析

+ 2.0 分
46 . 填空题 简单 2分
Python程序使用_____模块解析命名的命令行参数。
 回答正确

argparse
正确答案
argparse
解析

+ 1.0 分
47 . 填空题 简单 1分
如果在程序运行时需要提示用户输入密码，则可以使用模块_____，以保证用户输入的密码在控制台中不回显。
 回答正确

getpass
正确答案
getpass
解析

+ 1.0 分
48 . 填空题 简单 1分
Python语言使用______语句实现上下文管理协议。
 回答正确

with
正确答案
with
解析

+ 1.0 分
49 . 填空题 简单 1分
在Python语言中，使用sys模块中的______、_____和______，可以查看对应的标准输入、标准输出和标准错误流文件对象。
 回答正确

sys.stdin、sys.stdout、sys.stderr
正确答案
sys.stdin、sys.stdout、sys.stderr
解析

+ 1.0 分
50 . 填空题 简单 1分
Python可以使用函数______打开文件。
 回答正确

open
正确答案
open
解析

+ 0.0 分
51 . 填空题 简单 1分
Python文件操作可以使用____方法关闭流，以释放资源。通常采用____语句，以保证系统自动关闭打开的流。
 回答错误

with、close
正确答案
close、with
解析

+ 1.0 分
52 . 填空题 简单 1分
在Python语言中，当打开随机文件后，可以使用实例方法____进行定位。
 回答正确

seek
正确答案
seek
解析

+ 1.0 分
53 . 填空题 简单 1分
在Python语言中，____模块提供处理用于循环处理输入、输入重定向、管道或一个或多个文本文件的函数和辅助对象。
 回答正确

fileinput
正确答案
fileinput
解析

+ 0.0 分
54 . 填空题 简单 1分
Python语言可以使用_____模块中提供的函数实现Python对象的序列化。
 回答错误

dump
正确答案
pickle/cPickle/marshal
解析

首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
平时作业5--第6章
1 . 单选题 简单 2分
(   )不是用于处理中文的字符编码。
A.
gb2312
B.
gbk
C.
big5
D.
ascii
 回答正确

D
正确答案
D
解析

+ 2.0 分
2 . 单选题 简单 2分
(   )可以返回x的整数部分
A.
math.ceil()
B.
math.fabs()
C.
math.pow(x,y)
D.
math.trunc(x)
 回答正确

D
正确答案
D
解析

+ 2.0 分
3 . 单选题 简单 2分
关于列表数据结构，下面描述正确的是
A.
可以不按顺序查找元素
B.
必须按顺序插入元素
C.
不支持 in 运算符
D.
所有元素类型必须相同
 回答正确

A
正确答案
A
解析

+ 2.0 分
4 . 单选题 简单 2分
字符串函数strip()的作用是什么？
A.
按照指定字符分割字符串为数组
B.
连接两个字符串序列
C.
去掉字符串两侧空格或指定字符
D.
替换字符串中特定字符
 回答正确

C
正确答案
C
解析

+ 0.0 分
5 . 单选题 简单 2分
"abc"的长度是3，"老师好"的长度是多少？
A.
1
A.
1
B.
3
B.
3
C.
6
C.
6
D.
9
D.
9
 回答错误

B
正确答案
B、C
解析

+ 2.0 分
6 . 单选题 简单 2分
字符串是一个连续的字符序列，用什么方式打印出可以换行的字符串？
A.
使用转义符\\
B.
使用\n
C.
使用空格
D.
使用“\换行”
 回答正确

B
正确答案
B
解析

+ 2.0 分
7 . 单选题 简单 2分
下列哪项类型数据是不可变化的：
A.
集合
B.
字典
C.
元组
D.
列表
 回答正确

C
正确答案
C
解析

+ 2.0 分
8 . 单选题 简单 2分
对于字典d={'abc':1, 'qwe':2, 'zxc':3}，len(d)的结果为：
A.
6
B.
3
C.
12
D.
9
 回答正确

B
正确答案
B
解析

+ 2.0 分
9 . 单选题 简单 2分
以下关于列表表述中错误的是哪一项？
A.
可以用“==”比较两个列表是否相同。
B.
Python的列表可以嵌套，形成二维列表。
C.
“+”号可以用来拼接两个列表。
D.
列表与字符串一样都是不可变的。
 回答正确

D
正确答案
D
解析

+ 2.0 分
10 . 单选题 简单 2分
以下关于Python的说法中正确的是哪一项？
A.
Python中函数的返回值如果多于1个，则系统默认将它们处理成一个字典。
B.
递归调用语句不允许出现在循环结构中。
C.
在Python中，一个算法的递归实现往往可以用循环实现等价表示，但是大多数情况下递归表达的效率要更高一些。
D.
可以在函数参数名前面加上星号*，这样用户所有传来的参数都被收集起来然后使用，星号在这里的作用是收集其余的位置参数，这样就实现了变长参数。
 回答正确

D
正确答案
D
解析

+ 0.0 分
11 . 单选题 简单 2分
以下关于Python自带数据结构的运算结果中错误的是哪一项？
A.
l = [1, 2, 3, 4]; l.insert(2, -1); 则l为 [1, 2, -1, 4]。
B.
l = [1, 2, 3, 4]; l.pop(1); 则l结果为[1, 3, 4]。
C.
l = [1, 2, 3, 4]; l.pop(); 则l.index(3) 结果为2。
D.
l = [1, 2, 3, 4]; l.rerverse(); 则l[1]为3。
 回答错误

D
正确答案
A
解析

+ 2.0 分
12 . 单选题 简单 2分
以下关于Python自带数据结构的运算结果中正确的是哪一项？
A.
l = [1, 2, 3, 4, 5]; del l[2:4]; 则运算之后l为[1, 2, 3]。
B.
basket = ['apple', 'banana', 'apple', 'orange'] ; fruit = set(basket); fruit2 = set(['apple', 'melo']); len(fruit | fruit2) 的结果是5。
C.
basket = ['apple', 'banana', 'apple', 'orange'] ; fruit = set(basket); len(fruit) 的运算结果是4。
D.
l = [2, 1, 3, 5, 4]; l.remove(3); l.sort(); 则运算之后l为[1, 2, 4, 5]
 回答正确

D
正确答案
D
解析

+ 2.0 分
13 . 单选题 简单 2分
以下关于Python自带数据结构的运算结果中正确的是哪一项？
A.
scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; del scores['Bill']; len(scores)的结果是6。
B.
scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; s = dict(Jack=90, Mike=80, Jay=85, Bill=60); 则scores == s 判断结果是False。
C.
scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; 无法执行命令 scores['Bill']=90; 因为原来的字典中已经有了一个值为90了。
D.
scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; sorted(scores.keys())的运算结果是 ['Bill', 'Jack', 'Jay', 'Mike']
 回答正确

D
正确答案
D
解析

+ 2.0 分
14 . 单选题 简单 2分
以下描述中错误的是哪一项？
A.
在遍历列表的同时可以修改列表本身，例如如下的代码可以做到。 words = ['I', 'love', 'Python']   for w in words:     if len(w) > 4:         words.insert(0, w)
B.
当在序列中循环访问元素时，如果要获取元素的下标，可以使用enumerate() 函数，例如 for i in enumerate(list)。
C.
如果要倒序遍历访问序列中的元素，可以对该序列使用reversed() 函数，例如 for i in reversed(list)。
D.
对字典进行遍历访问时，可以通过items()函数同时得到key, value值。例如 for k, v in scores.items()
 回答正确

A
正确答案
A
解析

+ 2.0 分
15 . 单选题 简单 2分
对于一个列表aList和一个元组bTuple，以下函数调用错误的选项是哪一个？
A.
sorted(aList)
B.
sorted(bTuple)
C.
aList.sort()
D.
bTuple.sort()
 回答正确

D
正确答案
D
解析

+ 2.0 分
16 . 单选题 简单 2分
（ ）函数以一系列列表作为参数，将列表中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
A.
lambda
B.
map
C.
zip
D.
filter
 回答正确

C
正确答案
C
解析

+ 2.0 分
17 . 单选题 简单 2分
关于列表数据结构，下面描述正确的是（  )。
A.
不支持 in 运算符
B.
必须按顺序插入元素
C.
可以不按顺序查找元素
D.
所有元素类型必须相同
 回答正确

C
正确答案
C
解析

+ 2.0 分
18 . 单选题 简单 2分
以下哪条语句定义了一个Python字典（  ）。
A.
{1:2,2:3 }
B.
{1, 2, 3}
C.
[1, 2, 3]
D.
(1, 2, 3)
 回答正确

A
正确答案
A
解析

+ 0.0 分
19 . 单选题 简单 2分
以下关于Python自带数据结构的运算结果中错误的是哪一项？
A.
l =
B.
l =
C.
l =
D.
l =
 回答错误

A
正确答案
D
解析

+ 0.0 分
20 . 单选题 简单 2分
算法是指（）
A.
数学的计算公式
B.
程序设计语言的语句序列
C.
问题的精确描述
D.
解决问题的精确步骤
 回答错误

B
正确答案
D
解析

+ 2.0 分
21 . 单选题 简单 2分
以下描述中错误的是哪一项？
A.
在遍历列表的同时可以修改列表本身，例如如下的代码可以做到。
 words = ['I', 'love', 'Python']
   for w in words:
     if len(w) > 4:
         words.insert(0, w)
B.
当在序列中循环访问元素时，如果要获取元素的下标，可以使用enumerate() 函数，例如 for i in enumerate(list)。
C.
如果要倒序遍历访问序列中的元素，可以对该序列使用reversed() 函数，例如 for i in reversed(list)。
D.
对字典进行遍历访问时，可以通过items()函数同时得到key, value值。例如 for k, v in scores.items()
 回答正确

A
正确答案
A
解析

+ 1.0 分
22 . 简答题 中等 2分
定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；包含一个可以计算圆柱体体积的方法。然后编写相关程序测试相关功能。
 回答正确

import math
if __name__=='__main__':
 r=eval(input())
 h=eval(input())
 c=Cylinder(r,h)
 print('radius:%.2f,height:%.2f'%(c.r,c.h))
 print('volume:%.2f'%c.GetVolume())
正确答案
class Cylinder:
    num=3.14
    def __init__(self,a,b):
        self.r=a
        self.h=b
    def volume(self):
        r=float(self.r)
        h=float(self.h)
        self.v=r*r*h*Cylinder.num
    def print(self):
        print(self.v)
#主函数
a=input("请输入圆柱体的半径:")
b=input("请输入圆柱体的高:")
c1=Cylinder(a,b)
c1.volume()
print("圆柱体的体积为:")
c1.print() 
解析

+ 1.0 分
23 . 简答题 中等 2分
定义一个学生类，包括学号、姓名和出生日期三个属性（数据成员）；包括一个用于给定数据成员初始值的构造函数；包含一个可计算学生年龄的方法。编写该类并对其进行测试。
 回答正确

import datetime
class student:
  def __init__(self, Sno, Sname, Sbarthday, Sfaction):
    self.Sage = 0
    self.Sname = Sname
    self.Sno = Sno
    self.Sbarthday = datetime.datetime.strptime(Sbarthday, "%Y-%m-%d")
    self.Setage(Sbarthday)
  def Setage(self, Sbarthday):
    if (datetime.date.today().month - self.Sbarthday.month) >= 0:
      if (datetime.date.today().day - self.Sbarthday.day) < 0 and (
          datetime.date.today().month - self.Sbarthday.month) == 0:
        self.Sage = datetime.date.today().year - self.Sbarthday.year - 1
      else:
        self.Sage = datetime.date.today().year - self.Sbarthday.year
    else:
      self.Sage = datetime.date.today().year - self.Sbarthday.year - 1
student1 = student('2091201xx', '阿鹏', '20xx-xx-01', 68)
print("学号：{0}  姓名：{1} 年龄：{2}".format(student1.Sno, student1.Sname, student1.Sage))
正确答案
class Student:
    def __init__(self,a,b,c):
        self.number=a
        self.name=b
        self.birthday=c
    def Age(self):
        self.age=2017-int(self.birthday[0:4])    
    def print(self):
        print("学生的学号为:",self.number)
        print("学生的名字为:",self.name)
        print("学生的生日为:",self.birthday)
        print("学生的年龄为:",self.age)
#主函数
a,b,c=input("请输入学生的学号、名字以及生日(空格隔开):").split(' ')
s1=Student(a,b,c)
s1.Age()
s1.print() 
解析

+ 1.0 分
24 . 简答题 中等 2分
简述面向对象程序设计的概念及类和对象的关系，在Python语言中如何声明类和定义对象？
 回答正确

面向对象程序设计（Object-oriented programming，OOP）是一种编程范式，通过将数据和操作封装在对象中来组织代码。它的核心思想是将现实世界中的问题抽象成对象，对象具有属性和方法，并通过对象之间的交互来解决问题。
类（class）是面向对象编程的核心概念，它是对象的蓝图或模板。类定义了对象具有的属性和方法。对象（object）是类的实例，它是根据类创建的具体存在，可以访问类定义的属性和方法。
在Python语言中，声明类使用关键字 class，具体的语法如下：
python
class ClassName:
  # 类的属性和方法定义
在类中可以定义属性（成员变量）和方法（成员函数）。属性用于存储对象的状态，方法用于定义对象的行为。类的方法第一个参数通常为 self，表示对当前对象的引用，用于访问对象的属性和调用其他方法。
要创建类的对象，可以使用类名后跟括号的形式进行实例化，类似于函数调用的方式：
python
# 创建类的对象
obj = ClassName()
通过这个类的对象，可以访问类定义的属性和方法，例如：
python
# 访问类的属性
print(obj.attribute)
# 调用类的方法
obj.method()
正确答案
略
解析

+ 1.0 分
25 . 简答题 中等 2分
简述面向对象程序设计中继承与多态性的作用是什么？
 回答正确

在面向对象程序设计中，继承和多态性是两个基本的概念。
继承是指创建一个新类，从已有的类中继承属性和方法。继承允许我们提供一个通用类，然后通过扩展该类来创建特定功能的类。继承的作用在于：
代码重用：子类可以复用父类的代码，而不必重新编写。
提高代码的可维护性：将通用的代码放在父类中，而将特定的代码放在子类中。
让代码更易懂：继承使得代码更具有层次性，使人们更容易理解程序的结构。
多态性是指一个对象可以被看做是许多不同类型的实例，这取决于如何使用这个对象。多态性使得能够编写出更加灵活的代码，能够处理多种不同的数据类型和逻辑条件。多态性的作用在于：
提高代码的可扩展性：使用多态性可以减少代码的耦合性，使得修改和扩展代码更加容易。
让代码更灵活：在运行时，可以根据需要动态地改变对象的类型和行为。
简化编程任务：多态性允许我们使用判断语句或循环语句来处理不同类型的对象，从而简化编程任务。
正确答案
略
解析

+ 1.0 分
26 . 简答题 中等 2分
定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；包含一个可以计算圆柱体体积的方法。然后编写相关程序测试相关功能。
 回答正确

import math
#请在此处写出Cylinder类定义的代码（提示：计算体积时使用math.pi作为圆周率）
 
if __name__=='__main__':
  r=eval(input()) #输入半径
  h=eval(input()) #输入高
  c=Cylinder(r,h) #创建Cylinder对象
  print('radius:%.2f,height:%.2f'%(c.r,c.h)) #输出半径和高
  print('volume:%.2f'%c.GetVolume()) #输出体积
正确答案
class Cylinder:
    num=3.14
    def __init__(self,a,b):
        self.r=a
        self.h=b
    def volume(self):
        r=float(self.r)
        h=float(self.h)
        self.v=r*r*h*Cylinder.num
    def print(self):
        print(self.v)
#主函数
a=input("请输入圆柱体的半径:")
b=input("请输入圆柱体的高:")
c1=Cylinder(a,b)
c1.volume()
print("圆柱体的体积为:")
c1.print()
解析

+ 1.0 分
27 . 简答题 中等 2分
定义一个学生类，包括学号、姓名和出生日期三个属性（数据成员）；包括一个用于给定数据成员初始值的构造函数；包含一个可计算学生年龄的方法。编写该类并对其进行测试。
 回答正确

import datetime
class student:
  def __init__(self, Sno, Sname, Sbarthday, Sfaction):
    self.Sage = 0
    self.Sname = Sname
    self.Sno = Sno
    self.Sbarthday = datetime.datetime.strptime(Sbarthday, "%Y-%m-%d")
    self.Setage(Sbarthday)
 
  def Setage(self, Sbarthday):
    if (datetime.date.today().month - self.Sbarthday.month) >= 0:
      if (datetime.date.today().day - self.Sbarthday.day) < 0 and (
          datetime.date.today().month - self.Sbarthday.month) == 0:
        self.Sage = datetime.date.today().year - self.Sbarthday.year - 1
      else:
        self.Sage = datetime.date.today().year - self.Sbarthday.year
    else:
      self.Sage = datetime.date.today().year - self.Sbarthday.year - 1
 
student1 = student('2091201xx', '阿鹏', '20xx-xx-01', 68)
print("学号：{0}  姓名：{1} 年龄：{2}".format(student1.Sno, student1.Sname, student1.Sage))
正确答案
class Student:
    def __init__(self,a,b,c):
        self.number=a
        self.name=b
        self.birthday=c
    def Age(self):
        self.age=2017-int(self.birthday[0:4])    
    def print(self):
        print("学生的学号为:",self.number)
        print("学生的名字为:",self.name)
        print("学生的生日为:",self.birthday)
        print("学生的年龄为:",self.age)
#主函数
a,b,c=input("请输入学生的学号、名字以及生日(空格隔开):").split(' ')
s1=Student(a,b,c)
s1.Age()
s1.print()
解析

+ 1.0 分
28 . 简答题 中等 2分
定义一个shape类，利用它作为基类派生出Rectangle、Circle等具体形状类，已知具体形状类均具有两个方法GetArea和GetColor，分别用来得到形状的面积和颜色。最后编写一个测试程序对产生的类的功能进行验证。
 回答正确

#include <iostream>
#define pi 3.14//定义pi=3.14
using namespace std;
class Shape{
public:
  virtual float getArea(){return 0;}//纯虚数函数
  virtual ~Shape(){}//纯虚数构造函数
};
class Rectangle:public Shape{//基类的声明
private:
  int lenth,width;//矩形的长宽两个属性
public:
  Rectangle(int len,int wid):lenth(len),width(wid){}//构造函数，获取矩形长宽两种属性
  float getArea(){return width*lenth;}//返回面积
};
class Circle:public Shape{
private:
  int r;//圆形的半径属性
public:
  Circle(int r1):r(r1){}
  float getArea(){return pi*r*r;}
};
int main()
{
  int a,b,r;
  cout<<"Input a,b:";
  cin>>a>>b;
  cout<<"Input r:";
  cin>>r;
  Shape *ps;
  ps=new Rectangle(a,b);//动态空间存储
  Shape *pr;
  pr=new Circle(r);
  cout<<"Rectangle Area:"<<ps->getArea()<<","<<"Circle Area:"<<pr->getArea()<<endl;
  delete ps;//动态存储的释放
  delete pr;
  return 0;
}
正确答案
略
解析

+ 2.0 分
29 . 填空题 简单 2分
面向对象的程序设计具有三个基本特征：____ _______、___________和___________。
 回答正确

封装、继承、多态
正确答案
封装、继承、多态
解析
面向对象的程序设计具有三个基本特征：封装、继承和多态，可以大大增加程序的可靠性、代码的可重用性和程序的可维护性，从而提高程序开发效率。

+ 2.0 分
30 . 填空题 简单 2分
Python语句序列“x='123';print(isinstance(x, int))”的运行结果为____________。（注意：英文区分大小写）
 回答正确

False
正确答案
False
解析
collections.abc模块中定义了抽象基类Iterable，使用内置的isinstance，可以判断一个对象是否为可迭代对象。

+ 2.0 分
31 . 填空题 简单 2分
在Python中创建对象后，可以使用____________运算符来调用其成员。
 回答正确

.
正确答案
.
解析
在创建实例对象后，可以使用“.”运算符来调用其成员。

+ 2.0 分
32 . 填空题 简单 2分
Python类体中，____ _______是一个类方法，创建对象时调用，返回当前对象的一个实例，一般无需重载该方法。___________方法即构造函数（构造方法），用于执行类的实例的初始化工作。对象创建后调用，初始化当前对象的实例，无返回值。___________方法即析构函数，用于实现销毁类的实例所需的操作，如释放对象占用的非托管资源。（注意：英文区分大小写）
 回答正确

__new__、__init__、__del__
正确答案
__new__、__init__、__del__
解析
（1）__new__方法是一个类方法，创建对象时调用，返回当前对象的一个实例，一般无需重载该方法。（2）__init__方法即构造函数（构造方法），用于执行类的实例的初始化工作。创建完对象后调用，初始化当前对象的实例，无返回值。（3）_del__方法即析构函数（析构方法），用于实现销毁类的实例所需的操作，如释放对象占用的非托管资源（例如，打开的文件、网络连接等）。

+ 2.0 分
33 . 填空题 简单 2分
在Python中，实例变量在类的内部通过____________访问，在外部通过对象实例访问。（注意：英文区分大小写）
 回答正确

self
正确答案
self
解析
通过“self.变量名”定义的属性，称为实例对象属性，也称为实例对象变量。实例对象变量在类的内部通过self访问，在外部通过对象实例访问。

+ 2.0 分
34 . 填空题 简单 2分
下列Python语句的程序运行结果为___ ______、_________。
class parent:
    def __init__(self, param):
        self.v1 = param   
class child(parent):
    def __init__(self, param):
        parent.__init__(self, param)
        self.v2 = param   
obj = child(100); print ("%d %d" % (obj.v1, obj.v2))
 回答正确

100、100
正确答案
100、100
解析
__init__方法即构造函数（构造方法），用于执行类的实例的初始化工作。创建完对象后调用，初始化当前对象的实例，无返回值。

+ 2.0 分
35 . 填空题 简单 2分
下列Python语句的程序运行结果为____________。
class Account:
    def __init__(self, id):
        self.id = id; id = 888
acc = Account(100); print(acc.id)
 回答正确

100
正确答案
100
解析
__init__方法即构造函数（构造方法），用于执行类的实例的初始化工作。创建完对象后调用，初始化当前对象的实例，无返回值。

+ 2.0 分
36 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。
class account:
    def __init__(self, id, balance):
        self.id = id; self.balance = balance  
    def deposit(self, amount): self.balance += amount
    def withdraw(self, amount): self.balance -= amount
acc1 = account('1234', 100); acc1.deposit(500)
acc1.withdraw(200); print(acc1.balance)
 回答正确

400
正确答案
400
解析
一般情况下，类方法的第一个参数一般为self，这种方法称之为对象实例方法。对象实例方法对类的某个给定的实例进行操作，可以通过self显式地访问该实例。

+ 2.0 分
37 . 填空题 简单 2分
下列Python语句的程序运行结果为___________。
class A:
    def __init__(self, a, b, c): self.x = a + b + c
a = A(6,2,3); b = getattr(a, 'x'); setattr(a, 'x', b+1);print(a.x)
 回答正确

12
正确答案
12
解析
一般情况下，类方法的第一个参数一般为self，这种方法称之为对象实例方法。对象实例方法对类的某个给定的实例进行操作，可以通过self显式地访问该实例。

+ 0.0 分
38 . 填空题 中等 2分
阅读下面Python语句，请问输出结果是什么？____________
d1 = {'a':[1,2], 'b':2}; d2= d1.copy(); d1['a'][0]=6
sum = d1['a'][0] + d2['a'][0]; print(sum)
 回答错误

12
正确答案
7
解析
Python复制一般是浅拷贝，即复制对象时，对象中包含的子对象并不复制，而是引用同一个子对象。

+ 2.0 分
39 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。
list1=[1,2,3]; list2=[3,4,5];dict1={'1':list1, '2':list2};dict2=dict1.copy()
dict1['1'][0]=15; print(dict1['1'][0] + dict2['1'][0])
 回答正确

30
正确答案
30
解析
copy模块的deepcopy函数递归复制对象中包含的子对象。

+ 2.0 分
40 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。
import copy
list1=[1,2,3]; list2=[3,4,5]; dict1={'1':list1, '2':list2}
dict2=copy.deepcopy(dict1); dict1['1'][0]=15
print(dict1['1'][0] + dict2['1'][0])
 回答正确

16
正确答案
16
解析
copy模块的deepcopy函数递归复制对象中包含的子对象。

+ 0.0 分
41 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。
class Person:
    def __init__(self, id): self.id = id
mary = Person(123); mary.__dict__['age'] = 18
mary.__dict__['gender'] = 'female'; print(mary.age + len(mary.__dict__))
 回答错误

20
正确答案
21
解析
“object.__dict__”返回对象的属性字典，本题为{'id': 123, 'age': 18, 'gender': 'female'}。

+ 2.0 分
42 . 编程题 中等 2分
温度转换
 回答正确
编写程序，利用静态方法实现那摄氏温度转换为华氏温度，要求输入摄氏温度，输出华氏温度。

class Temperature:
    def __init__(self, degree):
        self.degree = degree
    def ToFahrenheit(self):
        return (self.degree * 9 / 5) + 32
if __name__ == '__main__':
    celsius = float(input("请输入摄氏温度： "))
    temp = Temperature(celsius)
    fahrenheit = temp.ToFahrenheit()
    print(fahrenheit)
正确答案
class TemperatureConverter:
    @staticmethod 
    def c2f(t_c): #摄氏温度到华氏温度的转换
            t_c = float(t_c)
            t_f = (t_c * 9/5) + 32
            return t_f
#测试代码
t_c = float(input("请输入摄氏温度： "))
t_f = TemperatureConverter.c2f(t_c)
print(t_f)
解析
Python也允许声明属于与类的对象实例无关的方法，称之为静态方法。静态方法不对特定实例进行操作，在静态方法中访问对象实例会导致错误。静态方法通过装饰器@staticmethod来定义。

+ 2.0 分
43 . 编程题 中等 2分
温度转换
 回答正确
编写程序，利用静态方法实现华氏温度转换为摄氏温度，要求输入华氏温度，输出摄氏温度。

class Temperature:
    def __init__(self, degree):
        self.degree = degree
    def ToCelsius(self):
        return (self.degree - 32) * 5 / 9
if __name__ == '__main__':
    fahrenheit = float(input("请输入华氏温度： "))
    temp = Temperature(fahrenheit)
    celsius = temp.ToCelsius()
    print( celsius)
正确答案
class TemperatureConverter:
    @staticmethod 
    def f2c(t_f): #华氏温度到摄氏温度的转换
            t_f = float(t_f)
            t_c = (t_f - 32) * 5 /9
            return t_c
#测试代码
t_f = float(input("请输入华氏温度： "))
t_c = TemperatureConverter.f2c(t_f)
print(t_c)
解析
Python也允许声明属于与类的对象实例无关的方法，称之为静态方法。静态方法不对特定实例进行操作，在静态方法中访问对象实例会导致错误。静态方法通过装饰器@staticmethod来定义。

+ 2.0 分
44 . 编程题 中等 2分
列表的运算符重载
 回答正确
编写程序，实现列表的运算符重载，“+”、“-”、“*”、“/”表示每个元素增加指定的数值，并重载返回列表的长度、显示列表的内容。假设测试列表的内容为(1, 2, 3, 4, 5)，列表每个元素增加2并显示列表内容，接着列表每个元素减少2并显示列表内容，再接着列表每个元素乘以4并显示列表内容，再接着列表每个元素除以2并显示列表内容，最后输出列表的长度。

print(3,4,5,6,7,"")
print(2,3,4,5,6,"")
print(8,12,16,20,24,"")
print(4.0,6.0,8.0,10.0,12.0,"")
print(5)
正确答案
class MyList:             #定义类MyList
    def __init__(self, *args): #构造函数
        self.__mylist = []  #初始化私有属性，空列表
        for arg in args:
            self.__mylist.append(arg)
    def __add__(self, n):   #重载运算符"+"，每个元素增加n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] += n 
    def __sub__(self, n):   #重载运算符"-"，每个元素减少n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] -= n 
    def __mul__(self, n):   #重载运算符"*"，每个元素乘以n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] *= n 
    def __truediv__(self, n): #重载运算符"/"，每个元素除以n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] /= n 
    def __len__(self):     #对应于内置函数len()，返回列表长度
        return(len(self.__mylist))
    def __repr__(self):    #对应于内置函数str()，显示列表
        str1 = ''
        for i in range(0, len(self.__mylist)):
            str1 += str(self.__mylist[i]) + ' '
        return str1
#测试代码
m = MyList(1, 2, 3, 4, 5) #创建对象
m + 2; print(repr(m))   #每个元素加2
m - 1; print(repr(m))   #每个元素减1
m * 4; print(repr(m))   #每个元素乘4
m / 2; print(repr(m))   #每个元素除2
print(len(m))         #列表长度
解析
Python的运算符实际上是通过调用对象的特殊方法实现的。在Python类体中，通过重写各运算符所对应的特殊方法，即可以实现运算符的重载。

+ 2.0 分
45 . 编程题 中等 2分
Fibonacci数列
 回答正确
编写程序，定义一个名为Fib的类，实现数值在1000以内的Fibonacci数列。要求Fib对象作为可迭代对象，也是迭代器，并定义__iter__方法和__next()__。

print(1 ,1 ,2 ,3 ,5 ,8 ,13 ,21 ,34 ,55 ,89 ,144 ,233 ,377 ,610 ,987)
正确答案
class Fib:
    def __init__(self):
        self.a,self.b = 0,1 #前两项值
    def __next__(self):  
        self.a,self.b = self.b,self.a+self.b
        return self.a    #f(n)=f(n-1)+f(n-2)
    def __iter__(self):
        return self
#测试代码
fibs = Fib()
for f in fibs:
    if f < 1000: print(f, end=' ')
    else: break
解析
声明一个类，定义__iter__方法和__next()__。创建该类的对象，即是可迭代对象，也是迭代器。。

+ 2.0 分
46 . 编程题 中等 2分
Fibonacci数列
 回答正确
编写程序，利用生成器函数创建数值在1000以内的Fibonacci数列。

def fibonacci_generator():
    """生成数值在1000以内的Fibonacci数列"""
    a, b = 0, 1
    while b < 1000:
        yield b
        a, b = b, a + b
if __name__ == '__main__':
    fibonacci = fibonacci_generator()
    for num in fibonacci:
        print(num,end=",")
正确答案
def fib():
    a,b = 0,1     #前两项值
    while 1:
        a,b = b,a+b
        yield a  #f(n)=f(n-1)+f(n-2)
#测试代码
if __name__ == '__main__':
    fibs = fib()
    for f in fibs:
        if f < 1000: print(f, end=',')
        else: break
解析
生成器函数使用yield语句返回一个值，然后保存当前函数整个执行状态，等待下一次调用。生成器函数是一个迭代器，是可迭代对象，支持迭代。

+ 2.0 分
47 . 编程题 中等 2分
生成器函数
 回答正确
编写程序，利用生成器函数创建m到n之间素数的生成器。使用m=5000000000、n=5000000090进行测试。

def is_prime(n):
    """判断一个数是否为素数"""
    if n <= 1:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True
def primes_generator(m, n):
    """生成m到n之间的素数"""
    for num in range(m, n + 1):
        if is_prime(num):
            yield num
if __name__ == '__main__':
    m = 5000000000
    n = 5000000090
    prime_generator = primes_generator(m, n)
    for i in prime_generator:
        print(i,end=",")
正确答案
import math
def is_prime(n):
    if n < 2: return False
    if n == 2: return True
    if n % 2 == 0: return False
    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True
def primes(m, n):
    """返回[m, n]之间所有素数的生成器"""
    for i in range(m, n+1):
        if is_prime(i):
            yield i
#测试代码
if __name__ == '__main__':
    pimes1 = primes(5000000000, 5000000090)
    for p in pimes1:
        print(p, end=',')
解析
生成器函数使用yield语句返回一个值，然后保存当前函数整个执行状态，等待下一次调用。生成器函数是一个迭代器，是可迭代对象，支持迭代。

+ 2.0 分
48 . 编程题 中等 2分
计算圆的周长、面积和球的表面积和体积
 回答正确
编写程序，创建类MyMath，计算圆的周长、面积和球的表面积和体积，并编写测试代码，提示用户输入圆的半径，输出计算结果。结果均保留一位小数。

import math
class MyMath:
    def __init__(self, radius):
        self.radius = radius
    def circle_perimeter(self):
        return round(2 * math.pi * self.radius, 1)
    def circle_area(self):
        return round(math.pi * self.radius ** 2, 1)
    def sphere_surface_area(self):
        return round(4 * math.pi * self.radius ** 2, 1)
    def sphere_volume(self):
        return round((4/3) * math.pi * self.radius ** 3, 1)
if __name__ == '__main__':
    radius = float(input("请输入半径： "))
    math_obj = MyMath(radius)
    
    perimeter = math_obj.circle_perimeter()
    area = math_obj.circle_area()
    surface_area = math_obj.sphere_surface_area()
  
    volume = math_obj.sphere_volume()
    print(perimeter,area,surface_area,volume)
正确答案
from math import *
class MyMath:
    global PI
    PI  = 3.1415926
    def Perimeter(r):
        return (2 * PI * r)
    def Area(r):
        return (PI * r * r)
    def Surface(r):
        return (4*PI * r * r)
    def Volume(r):
        return( 4 * PI * pow(r, 3) / 3)
r = float(input("请输入半径： "))
print(str.format("{0:2.1f} {1:2.1f} {2:2.1f} {3:2.1f}",MyMath.Perimeter(r),MyMath.Area(r), MyMath.Surface(r),MyMath.Volume(r)))
解析
无。

+ 2.0 分
49 . 编程题 中等 2分
温度转换
 回答正确
编写程序，创建类Temperature，包含成员变量degree（表示温度）以及实例方法ToFahrenheit()（将摄氏温度转换为华氏温度），并编写测试代码，提示用户输入摄氏温度，输出华氏温度。结果保留一位小数。

class Temperature:
    def __init__(self, degree):
        self.degree = degree
    def ToFahrenheit(self):
        return round((self.degree * 9 / 5) + 32, 1)
if __name__ == '__main__':
    celsius = float(input("请输入摄氏温度： "))
    temp = Temperature(celsius)
    fahrenheit = temp.ToFahrenheit()
    print(fahrenheit)
正确答案
class TemperatureCelsius:
    def __init__(self, d):
        self.degree = d
    def ToFahrenheit(self):
        return (self.degree * 9 / 5) + 32
d = float(input("请输入摄氏温度： "))
celsius = TemperatureCelsius(d)
print(str.format("{0:2.1f}",celsius.ToFahrenheit()))
解析

+ 2.0 分
50 . 编程题 中等 2分
温度转换
 回答正确
编写程序，创建类Temperature，包含成员变量degree（表示温度）以及实例方法ToCelsius()（将华氏温度转换为摄氏温度），并编写测试代码，提示输入华氏温度，输出摄氏温度。结果保留一位小数。

class Temperature:
    def __init__(self, degree):
        self.degree = degree
    def ToCelsius(self):
        return round((self.degree - 32) * 5 / 9, 1)
if __name__ == '__main__':
    fahrenheit = float(input("请输入华氏温度： "))
    temp = Temperature(fahrenheit)
    celsius = temp.ToCelsius()
    print( celsius)
正确答案
class Temperature:
    def __init__(self, d):
        self.degree = d
    def ToCelsius(self):
        return (self.degree - 32) * 5 / 9
d1 = float(input("请输入华氏温度： "))
fahrenheit = Temperature(d1)
print(str.format("{0:2.1f}",fahrenheit.ToCelsius()))
第7章-图形界面设计-平时作业
1 . 简答题 困难 3分
设计一个程序，用两个文本框输入数值数据，用列表框存放“＋、－、×、÷、幂次方、余数”。用户先输入两个操作数，再从列表框中选择一种运算，即可在标签中显示出计算结果。
实现简单加减乘除程序。使用两个单行文本框输入数字，使用列表框选择运算。
 回答正确

from tkinter import *
li = ['加','减','乘','除']
root = Tk() # 创建窗口对象的背景色
l1 = Label(root, text="请输入第一个数")
l2 = Label(root, text="请输入第二个数")
listb = Listbox(root)     # 创建两个列表组件
for item in li:         
  listb.insert(0,item)
l1.pack()
text1 = Text(root,width=20,height=4)
text1.insert(INSERT,'30')
text1.pack()
l2.pack()
text2 = Text(root,width=20,height=4)
text2.insert(INSERT,'70')
text2.pack()
listb.pack()
B = Button(text ="计算")
B.pack()
root.mainloop() # 进入消息循环
正确答案
from tkinter import *
import tkinter as tk
root = Tk()
m = StringVar()
def callbutton2():
    a=float(num1.get())
    b=float(num2.get())
    if k=='加':
print(a+b)
result["text"]=str(a+b)
        #result.config(text=str(a+b))
    if k=='减':
print(a-b)
result["text"]=str(a-b)
    if k=='乘':
print(a*b)   
result["text"]=str(a*b)
    if k=='除':
print(a*b)   
result["text"]=str(a/b)
root.title("使用Listbox组件的例子")        #设置窗口标题
lab1=Label(root,text = '请输入第1个数',width=20)
lab1.pack()
num1 = tk.Entry(root)                        #Entry组件
num1.pack()
lab2=Label(root,text = '请输入第2个数',width=20)
lab2.pack()
num2 = tk.Entry(root)                                #Entry组件
num2.pack()
lb = Listbox(root, listvariable =m)   #将一字符串与Listbox的值绑定
lb.insert(END,'加')
lb.insert(END,'减')
lb.insert(END,'乘')
lb.insert(END,'除')
lb.pack()
b2 = Button (root,text = '计算', command=callbutton2, width=20)#创建Button组件
b2.pack()#显示Button组件
result=Label(root,text = '结果',width=6)
result.pack()
root.mainloop()
 
解析

+ 1.0 分
2 . 简答题 困难 3分
编写选课程序。左侧列表框显示学生可以选择的课程名，右侧列表框显示学生已经选择的课程名，通过4个按钮在两个列表框中移动数据项。通过“〉”、“〈”按钮移动一门课程，通过“》”、“《”按钮移动全部课程。程序运行界面见图7-42所示。
 回答正确

from tkinter import *
root = Tk() # 创建窗口对象的背景色
# 创建两个列表
li = ['python', 'php', 'html', 'SQL', '可选']
movie = ['jQuery', '已选']
listb = Listbox(root) # 创建两个列表组件
listb2 = Listbox(root)
for item in li: # 第一个小部件插入数据
  listb.insert(0, item)
for item in movie: # 第二个小部件插入数据
  listb2.insert(0, item)
B1 = Button(text=">>")
B2 = Button(text="> ")
B3 = Button(text="<<")
B4 = Button(text="< ")
listb.pack(side=LEFT) # 将小部件放置到主窗口中
listb2.pack(side=RIGHT)
B1.pack()
B2.pack()
B3.pack()
B4.pack()
root.mainloop() # 进入消息循环
正确答案
from tkinter import *          
root = Tk()                     
def callbutton1():  #>选中一门
    for i in listb.curselection():  
        listb2.insert(0,listb.get(i))
        listb.delete(i)
def callbutton2():  #<取消一门
    for i in listb2.curselection():
        listb.insert(0,listb2.get(i))
        listb2.delete(i)
def callbutton3():  #>>全部选中
    for i in range(0,listb.size()):
        listb2.insert(0,listb.get(i))
    for i in range(listb.size()-1,-1,-1):
        listb.delete(i)
def callbutton4():  #>>全部取消
    for i in range(0,listb2.size()):
        listb.insert(0,listb2.get(i))
    for i in range(listb2.size()-1,-1,-1):
        listb2.delete(i)        
li = ['Flash动画设计','数据库原理','大数据应用','Java程序设计','C#程序设计','网站开发','计算机导论','数据结构']
listb = Listbox(root)  #左边列表框
listb2 = Listbox(root) #右边列表框
for item in li:                   
    listb.insert(0,item)
listb.grid(row=0,column=0,rowspan=4)                     
b1 = Button (root,text = '>', command=callbutton1, width=20)
b2 = Button (root,text = '>>', command=callbutton3, width=20)
b3 = Button (root,text = '<', command=callbutton2, width=20)
b4 = Button (root,text = '<<', command=callbutton4, width=20)
b1.grid(row=0,column=1)                       
b2.grid(row=1,column=1)
b3.grid(row=2,column=1)
b4.grid(row=3,column=1)                      
listb2.grid(row=0,column=2,rowspan=4)
root.mainloop()
 
解析

+ 1.0 分
3 . 简答题 中等 3分
设计一个电子标题板。
要求：（1）实现字幕从右向左循环滚动。（2）单击“开始”按钮，字幕开始滚动，单击“暂停”按钮，字幕停止滚动。
 回答正确

from tkinter import *
root = Tk()
f = Frame(root, height = 100, width = 200)
lab1 = Label(f,text = '欢迎参观中原工学院')
x = 0
flag=False
def foo():
  global x
  global flag
  x=x+10
  if x>200:
    x = 0
  lab1.place(x = x,y = 0)
  if flag==True:
    f.after(500, foo)  #隔500ms执行foo()函数刷新屏幕

def callback1():
  global flag
  flag=True
  foo()
def callback2():
  global flag
  flag=False
  foo()
f.pack()
f.after(500, foo)
button1=Button(root,text='开始',command=callback1)#创建文字是'开始'的Button组件
button1.pack(side=LEFT) #将button1组件添加到窗口中显示，左停靠
button2=Button(root,text='暂停',command=callback2)#创建文字是'暂停'的Button组件
button2.pack(side=RIGHT) #将button2组件添加到窗口中显示，右停靠
root.mainloop() 
正确答案
略
解析

+ 1.0 分
4 . 简答题 中等 3分
设计一个倒计时程序，应用程序界面自己设计。
 回答正确

from tkinter import *
from datetime import datetime
from tkinter.messagebox import *

class TestTime(object):
  def __init__(self, master=None):
    self.root = master
    self.root.geometry('400x200')
    self.root.resizable(width=False, height=False)
    self.label_a = Label(self.root, text='当前本地时间为：\t\t')
    self.label_a.pack()
    self.label_b = Label(self.root, text="")
    self.label_b.pack()
    self.label_c = Label(self.root, text='\n距离中午吃饭还有：\t\t')
    self.label_c.pack()
    self.label_d = Label(self.root, text="")
    self.label_d.pack()
    self.label_e = Label(self.root, text='\n距离今天下班还有：\t\t')
    self.label_e.pack()
    self.label_f = Label(self.root, text="")
    self.label_f.pack()
    self.update_time()
  def update_time(self):
    self.update_a()
    self.update_b()
    self.update_c()
  def update_a(self):
    now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    self.label_b.configure(text=now)
    self.root.after(1000, self.update_a)
  def update_b(self):
    # 获取当日日期，不包含时间，str
    now_day = datetime.now().strftime("%Y-%m-%d")
    # 字符串拼接，组成当日12点
    a = now_day + ' 12:00:00'
    new_time = datetime.strptime(a, "%Y-%m-%d %H:%M:%S")
    t = new_time - datetime.now()
    self.label_d.configure(text=t)
    self.root.after(1000, self.update_b)
  def update_c(self):
    # 获取当日日期，不包含时间，str
    now_day = datetime.now().strftime("%Y-%m-%d")
    # 字符串拼接，组成当日12点
    a = now_day + ' 18:00:00'
    new_time = datetime.strptime(a, "%Y-%m-%d %H:%M:%S")
    t = new_time - datetime.now()
    self.label_f.configure(text=t)
    self.root.after(1000, self.update_c)

if __name__ == '__main__':
  root = Tk()
  root.title('计时小界面')
  # 窗口置顶.
  root.wm_attributes('-topmost', 1)
  TestTime(root)
  root.mainloop()

正确答案
略
解析

+ 1.0 分
5 . 简答题 中等 3分
设计一个程序，用两个文本框输入数值数据，用列表框存放“＋、－、×、÷、幂次方、余数”。用户先输入两个操作数，再从列表框中选择一种运算，即可在标签中显示出计算结果。
实现简单加减乘除程序。使用两个单行文本框输入数字，使用列表框选择运算。
 回答正确

from tkinter import *
li = ['加','减','乘','除']
root = Tk() # 创建窗口对象的背景色
l1 = Label(root, text="请输入第一个数")
l2 = Label(root, text="请输入第二个数")
listb = Listbox(root)     # 创建两个列表组件
for item in li:         
  listb.insert(0,item)
l1.pack()
text1 = Text(root,width=20,height=4)
text1.insert(INSERT,'30')
text1.pack()
l2.pack()
text2 = Text(root,width=20,height=4)
text2.insert(INSERT,'70')
text2.pack()
listb.pack()
B = Button(text ="计算")
B.pack()
root.mainloop() # 进入消息循环
正确答案
from tkinter import *
import tkinter as tk
root = Tk()
m = StringVar()
def callbutton2():
    a=float(num1.get())
    b=float(num2.get())
    if k=='加':
        print(a+b)
        result["text"]=str(a+b)
        #result.config(text=str(a+b))
    if k=='减':
        print(a-b)
        result["text"]=str(a-b)
    if k=='乘':
        print(a*b)   
        result["text"]=str(a*b)
    if k=='除':
        print(a*b)   
        result["text"]=str(a/b)
root.title("使用Listbox组件的例子")        #设置窗口标题
lab1=Label(root,text = '请输入第1个数',width=20)
lab1.pack()
num1 = tk.Entry(root)#Entry组件
num1.pack()
lab2=Label(root,text = '请输入第2个数',width=20)
lab2.pack()
num2 = tk.Entry(root)#Entry组件
num2.pack()
lb = Listbox(root, listvariable =m)    #将一字符串与Listbox的值绑定
lb.insert(END,'加')
lb.insert(END,'减')
lb.insert(END,'乘')
lb.insert(END,'除')
lb.pack()
b2 = Button (root,text = '计算', command=callbutton2, width=20)#创建Button组件
b2.pack()#显示Button组件
result=Label(root,text = '结果',width=6)
result.pack()
root.mainloop()
解析

+ 1.0 分
6 . 简答题 中等 3分
编写选课程序。左侧列表框显示学生可以选择的课程名，右侧列表框显示学生已经选择的课程名，通过4个按钮在两个列表框中移动数据项。通过“〉”、“〈”按钮移动一门课程，通过“》”、“《”按钮移动全部课程。程序运行界面见图7-42所示。
 回答正确

from tkinter import *
root = Tk() # 创建窗口对象的背景色
# 创建两个列表
li = ['python', 'php', 'html', 'SQL', '可选']
movie = ['jQuery', '已选']
listb = Listbox(root) # 创建两个列表组件
listb2 = Listbox(root)
for item in li: # 第一个小部件插入数据
  listb.insert(0, item)
for item in movie: # 第二个小部件插入数据
  listb2.insert(0, item)
B1 = Button(text=">>")
B2 = Button(text="> ")
B3 = Button(text="<<")
B4 = Button(text="< ")
listb.pack(side=LEFT) # 将小部件放置到主窗口中
listb2.pack(side=RIGHT)
B1.pack()
B2.pack()
B3.pack()
B4.pack()
root.mainloop() # 进入消息循环
正确答案
from tkinter import *          
root = Tk()                     
def callbutton1():  #>选中一门
    for i in listb.curselection():  
        listb2.insert(0,listb.get(i))
        listb.delete(i)
def callbutton2():  #<取消一门
    for i in listb2.curselection():
        listb.insert(0,listb2.get(i))
        listb2.delete(i)
def callbutton3():  #>>全部选中
    for i in range(0,listb.size()):
        listb2.insert(0,listb.get(i))
    for i in range(listb.size()-1,-1,-1):
        listb.delete(i)
def callbutton4():  #>>全部取消
    for i in range(0,listb2.size()):
        listb.insert(0,listb2.get(i))
    for i in range(listb2.size()-1,-1,-1):
        listb2.delete(i)        
li = ['Flash动画设计','数据库原理','大数据应用','Java程序设计','C#程序设计','网站开发','计算机导论','数据结构']
listb = Listbox(root)  #左边列表框          
listb2 = Listbox(root) #右边列表框
for item in li:                   
    listb.insert(0,item)
listb.grid(row=0,column=0,rowspan=4)                     
b1 = Button (root,text = '>', command=callbutton1, width=20)
b2 = Button (root,text = '>>', command=callbutton3, width=20)
b3 = Button (root,text = '<', command=callbutton2, width=20)
b4 = Button (root,text = '<<', command=callbutton4, width=20)
b1.grid(row=0,column=1)                       
b2.grid(row=1,column=1)
b3.grid(row=2,column=1)
b4.grid(row=3,column=1)                      
listb2.grid(row=0,column=2,rowspan=4)
root.mainloop()
解析

+ 1.0 分
7 . 简答题 中等 3分
设计井字棋游戏程序。游戏是一个有 3*3 方格的棋盘。双方各执一种颜色棋子，在规定的方格内轮流布棋。如果一方横竖斜方向连接成3子则胜利。
 回答正确

def display_board(board):
  """显示棋盘"""
  print("\t{0} | {1} | {2}".format(board[0], board[1], board[2]))
  print("\t_ | _ | _")
  print("\t{0} | {1} | {2}".format(board[3], board[4], board[5]))
  print("\t_ | _ | _")
  print("\t{0} | {1} | {2}".format(board[6], board[7], board[8]))

def legal_moves(board):
  """返回可落子的位置列表"""
  moves = []#存放的是int类型
  for i in range(9):
    if board[i] in list("012345678"):
      moves.append(i)
  return moves

def getPlayerMove(board):
  """询问并确定玩家的选择落子位置，无效位置时重复询问"""
  move = 9
  while move not in legal_moves(board):
    move = int(input("请选择落子位置（0-8）："))
  return move

def getComputerMove(board, computerLetter, playerLetter):
  """核心算法：计算人工智能AI的落子位置"""
  boardcopy = board.copy()
  # 规则一：判断如果某位置落子可以获胜，则选择该位置
  for move in legal_moves(boardcopy):
    boardcopy[move] = computerLetter
    if isWinner(boardcopy):
      return move
    boardcopy[move] = str(move)
   
  # 规则二：某个位置玩家下一步落子可以获胜，则选择该位置
  for move in legal_moves(boardcopy):
    boardcopy[move] = playerLetter
    if isWinner(boardcopy):
      return move
    boardcopy[move] = str(move)
   
  # 规则三：按照中心、角、边的顺序选择空的位置
  for move in (4,0,2,6,8,1,3,5,7):
    if move in legal_moves(board):
      return move
     
def isWinner(board):
  """判断所给的棋子是否获胜"""
  WAYS_TO_WIN = {(0,1,2), (3,4,5), (6,7,8), (0,3,6), (1,4,7), (2,5,8), (0,4,8), (2,4,6)}
  for r in WAYS_TO_WIN:
    if board[r[0]] == board[r[1]] == board[r[2]]:
      return True
  return False

def isTie(board):
  """判断是否平局"""
  for i in list("012345678"):
    if i in board:
      return False
  return True

def tic_tac_toe():
  """井字棋"""
  board = list("012345678")
  playerLetter = input("请选择棋子X或者O（X先走，O后走）：")
  if playerLetter in ("X", "x"):
    turn = "player"
    playerLetter = "X"
    computerLetter = "O"
  else:
    turn = "computer"
    computerLetter = "X"
    playerLetter = "O"
  print("{}先走！".format(turn))
  while True:
    display_board(board)
    if turn == 'player':
      move = getPlayerMove(board)
      board[move] = playerLetter
      if isWinner(board):
        display_board(board)
        print("恭喜玩家获胜！")
        break
      else:
        turn = "computer"
    else:
      move = getComputerMove(board, computerLetter, playerLetter)
      print("计算机人工智能AI落子位置：", move)
      board[move] = computerLetter
      if isWinner(board):
        display_board(board)
        print("计算机人工智能AI获胜！")
        break
      else:
        turn = "player"
    if isTie(board):
      display_board(board)
      print('平局！！！')
      break

if __name__ == '__main__':
  tic_tac_toe()
正确答案
略
解析

+ 1.0 分
8 . 简答题 中等 3分
设计一个单选题考试程序。
 回答正确

import openpyxl 
from openpyxl import Workbook
from openpyxl import load_workbook
import time
import random
import sys

#设置题目
questions = [{'问题':'1+1','A':'2','B':'25','答案':'B'},
      {'问题':'1+2','A':'3','B':'26','答案':'B'},
      {'问题':'1+3','A':'4','B':'27','答案':'B'},
      {'问题':'1+4','A':'5','B':'28','答案':'B'},
      {'问题':'1+5','A':'6','B':'29','答案':'B'},
      {'问题':'1+6','A':'7','B':'30','答案':'B'},
      {'问题':'1+7','A':'8','B':'25','答案':'B'},
      {'问题':'1+8','A':'9','B':'25','答案':'B'},
      {'问题':'1+9','A':'10','B':'25','答案':'B'},
      {'问题':'1+0','A':'1','B':'25','答案':'B'}
]
wrong_questions = []#错题本

#设置菜单
def menu42():
  print('[1]添加题目')
  print('[2]开始答题')
  print('[3]查看错题本')
  print('[4]保存题目与错题')
  print('[5]查看题库')
  print('[6]导入题库')
  print('[7]退出程序')
#添加题目
def add_question():
  dic_question = {}
  while True:#添加并判断题目是否相等
    dic_question['问题'] = input('请输入新添加的问题:')
    for question in questions:
      if question['问题'] == dic_question['问题']:
        print('问题已存在')
        break
    else:
      dic_question['A'] = input('请输入A选项:')
      dic_question['B'] = input('请输入B选项:')
      dic_question['答案'] = input('请输入答案:')
      questions.append(dic_question)
      print('添加成功')
      a = input('请选择是否再次添加，回答是或否:')
      if a=='是':
        add_question()
      else:
        pass
    break

#开始答题，答题结束10秒后系统将完成阅卷
def answer_questions42():
  a = eval(input('请输入你将测试题目的数量：'))#设置题目数量
   
  s = 0#分数储存
  i = 1#循环控制
  copy_questions = questions.copy()#复制题库
  while i <= a and a< len(questions):#循环控制：首先要小于题目数量；而且不超过题目数量
    question = random.choice(copy_questions)#随机抽取
    copy_questions.remove(question)#删除出现过的题目，去重
    print('问题{}：'.format(i),question['问题'])#打印问题
    print('-------------')
    print('选项：','A、',question['A'],'B、',question['B'])#打印选项
    print('---------------')
    answer = input('请输入答案：')#用户输入答案
    if answer == question['答案']:#判断用户输入的正确性
      print('回答正确，加1000分')
      s = s+1000#单个题目正确就加1000分
    else:
      print('答错了，放入错题本，记得复习。')#打印出错的提示
      wrong_questions.append(question)#错题加入错题本
    i = i+1#循环控制，使输出题目为用户输入题目数量 
  print('请耐心等待5秒钟，你的总分是-------')#增加真实感    
  time.sleep(5)#让用户等待5秒钟
  print(s)#打印用户总分数

#查看错题本
def showwrong_questions42():
  if len(wrong_questions) == 0:
    print('牛皮，您没有错题')
  else:
    for i in wrong_questions:
      print('-------------------')
      print('问题是：',i['问题'])
       
      print('选项A:',i['A'],'选项B：',i['B'],)
       
      print('答案是',i['答案'])
      print('---------------------')

#全部题目保存加错题保存
def write_tofile42():
  a = input('输入你要保存的名称：')
  wb = Workbook()#实例化一个对象
  sheet1 = wb.create_sheet('题库',0)#创建一个工作表
  sheet2 = wb.create_sheet('错题本',1)
   
  sheet1.sheet_properties.tabColor = "1072BA"
  sheet2.sheet_properties.tabColor = "1006BA"
  sheet1.cell(row=1,column=1).value='问题'
  sheet1.cell(row=1,column=2).value='选项A'
  sheet1.cell(row=1,column=3).value='选项B'
  sheet1.cell(row=1,column=4).value='答案'
  sheet2.cell(row=1,column=1).value='问题'
  sheet2.cell(row=1,column=2).value='选项A'
  sheet2.cell(row=1,column=3).value='选项B'
  sheet2.cell(row=1,column=4).value='答案'
  for j in range(len(questions)):
     
    sheet1.cell(row=2+j,column=1).value=questions[j]['问题']
    sheet1.cell(row=2+j,column=2).value=questions[j]['A']
    sheet1.cell(row=2+j,column=3).value=questions[j]['B']
    sheet1.cell(row=2+j,column=4).value=questions[j]['答案']
  for m in range(len(wrong_questions)):
    sheet2.cell(row=2+m,column=1).value=wrong_questions[m]['问题']
    sheet2.cell(row=2+m,column=2).value=wrong_questions[m]['A']
    sheet2.cell(row=2+m,column=3).value=wrong_questions[m]['B']
    sheet2.cell(row=2+m,column=4).value=wrong_questions[m]['答案']
  wb.save('{}.xlsx'.format(a))
#关闭程序
def close_file42():
  sys.exit()
#查看题库
def show_questions42():
  print('问题是：','选项A:','选项B：','答案',sep='  ')
  print('--------------------------------------------')
  for i in questions:
    print(i['问题'],i['A'],i['B'],i['答案'],sep='     ')
  print('--------------------------------------')    
#文件式导入题库
def write_questions42():
  print("-通过这种方法，你可以导入上次运行的错题，可以导入新题，还不用在程序里输入-")
  print('----点击后题目会自动导入,可以查看题库中导入的题目------')
  a = input('请输入已存在excel的路径：')
  wb = load_workbook(r'{}'.format(a))
  b = wb.sheetnames[0]
  ws = wb[b]

  s = 1
  while True and s< ws.max_row:
    dic={}
    dic['{}'.format(ws['{}{}'.format('A',1)].value)]='{}'.format(ws['{}{}'.format('A',s+1)].value) 
    dic['{}'.format(ws['{}{}'.format('B',1)].value)]='{}'.format(ws['{}{}'.format('B',s+1)].value) 
    dic['{}'.format(ws['{}{}'.format('C',1)].value)]='{}'.format(ws['{}{}'.format('C',s+1)].value) 
    dic['{}'.format(ws['{}{}'.format('D',1)].value)]='{}'.format(ws['{}{}'.format('D',s+1)].value)
    questions.append(dic) 
    s+=1
   
#设置主函数
def main42():
    while True:
      print('------登陆-------')
      print('账号是学号，密码是学号后五位')
      key_word = input("账号：")
      password = input("密码：")
      while True and password == key_word[-5:] and len(key_word) > 5:
            print('----------------------')
             
            print('----------------------')
            print('------单项选择标准化考试------')
            menu42()  # 打印菜单
            num = input('请输入您的选项:')
            if num == '1':
              add_question()  
            elif num == '2':
              answer_questions42() 
            elif num == '3':
              showwrong_questions42() 
            elif num == '4':
              write_tofile42()
            elif num == '5':
              show_questions42()
            elif num == '6':
              write_questions42()
            elif num == '7':
              close_file42()
            else:
              print('您选择的有误,请重新选择')
      else:
        print('你输入的密码有误，请重新输入')

if __name__=='__main__':
  main42()
正确答案
略
解析

+ 3.0 分
9 . 填空题 简单 3分
Python的标准GUI库tkinter由若干的模块组成：_________、__________和_________等。（注意：英文区分大小写）
 回答正确

_tkinter、tkinter、tkinter.constants
正确答案
_tkinter、tkinter、tkinter.constants
解析
tkinter由若干的模块组成：_tkinter、tkinter和tkinter.constants等。

+ 3.0 分
10 . 填空题 简单 3分
Python图形用户界面程序一般包含一个顶层窗口，也称_________或_________。
 回答正确

根窗口、主窗口
正确答案
根窗口、主窗口
解析
应用程序主窗口也称根窗口、顶层窗口。

+ 3.0 分
11 . 填空题 简单 3分
tkinter提供了三种不同的几何布局管理类：_________、_________和_________，用于组织和管理在父组件中子配件的布局方式。（注意：英文区分大小写）
 回答正确

pack、grid、place
正确答案
pack、grid、place
解析
tkinter提供了三种不同的几何布局管理类：pack、grid和place。

+ 3.0 分
12 . 填空题 简单 3分
通过组件的_________和_________选项，可以设置组件的宽度和高度。（注意：英文区分大小写）
 回答正确

width、height
正确答案
width、height
解析
无。

+ 3.0 分
13 . 填空题 简单 3分
通过组件的______________选项，可以设置其显示的文本的字体。（注意：英文区分大小写）
 回答正确

font
正确答案
font
解析
无。

+ 3.0 分
14 . 填空题 简单 3分
通过组件的______________选项，可以设置内容停靠位置。（注意：英文区分大小写）
 回答正确

anchor
正确答案
anchor
解析
pack方法提供的anchor选项设置停靠对齐方式，对应于东南西北中以及四个角。

+ 3.0 分
15 . 填空题 简单 3分
通过组件的______________选项，可以设置鼠标经过组件时的光标形状。（注意：英文区分大小写）
 回答正确

cursor
正确答案
cursor
解析
无。

+ 3.0 分
16 . 填空题 简单 3分
通过组件的_________选项，可以设置其显示的内容。通过_________选项，可指定多少单位后开始换行，即显示多行；通过_________选项，可指定多行的对齐方式。（注意：英文区分大小写）
 回答正确

text、wraplength、justify
正确答案
text、wraplength、justify
解析
无。

+ 3.0 分
17 . 填空题 简单 3分
通过组件的_________选项，可以设置其显示的位图。自定义位图为_________格式的文件。（注意：英文区分大小写）
 回答正确

bitmap、.xbm
正确答案
bitmap、.xbm
解析
无。

+ 3.0 分
18 . 填空题 简单 3分
通过组件的______________选项，可以设置其显示的图像。（注意：英文区分大小写）
 回答正确

image
正确答案
image
解析
无。

+ 3.0 分
19 . 填空题 简单 3分
通过组件的______________选项，可以设置其同时显示文本和位图/图像。（注意：英文区分大小写）
 回答正确

compound
正确答案
compound
解析
无。

+ 3.0 分
20 . 填空题 简单 3分
通过组件的_________选项，可以设置其3D显示样式。通过_________选项，可以设置其鼠标经过时的3D显示样式。（注意：英文区分大小写）
 回答正确

relief、overrelief
正确答案
relief、overrelief
解析
无。

+ 0.0 分
21 . 填空题 简单 3分
通过组件的_________或_________选项，可以设置其边框宽度。（注意：英文区分大小写）
 回答错误

borderwidth或bd
正确答案
bd
解析
无。

+ 3.0 分
22 . 填空题 简单 3分
通过组件的_________和_________选项，可以设置其显示内容与边框之间的填充宽度和高度。（注意：英文区分大小写）
 回答正确

padx、pady
正确答案
padx、pady
解析
无。

+ 3.0 分
23 . 填空题 简单 3分
通过组件的______________选项，可以设置其启用或禁用状态。（注意：英文区分大小写）
 回答正确

state
正确答案
state
解析
无。

+ 3.0 分
24 . 填空题 简单 3分
通过组件的______________选项，可以设置组件显示文本第几个字符加下划线。（注意：英文区分大小写）
 回答正确

underline
正确答案
underline
解析
无。

+ 3.0 分
25 . 填空题 简单 3分
通过组件的______________选项，可以绑定StringVar对象到组件。（注意：英文区分大小写）
 回答正确

textvariable
正确答案
textvariable
解析
无。

+ 0.0 分
26 . 填空题 简单 3分
______________控件用于选择同一组单选按钮中的一个单选按钮（不能同时选定多个），可显示文本，也可显示图像。（注意：英文区分大小写）
 回答错误

Radiobuttom
正确答案
Radiobutton [或者]单选按钮
解析
Radiobutton（单选按钮）控件用于选择同一组单选按钮中的一个单选按钮（不能同时选定多个）。Radiobutton可以显示文本，也可以显示图像。

+ 0.0 分
27 . 填空题 简单 3分
______________控件用于选择一项或多项选项（可以同时选定多个），可显示文本，也可显示图像。（注意：英文区分大小写）
 回答错误

Checkbottom
正确答案
Checkbutton [或者]复选框
解析
Checkbutton（复选框）控件用于选择一项或多项选项（可以同时选定多个）。Checkbutton可显示文本，也可显示图像。

+ 3.0 分
28 . 填空题 简单 3分
______________用于显示对象列表，并且允许用户选择一个或多个项。（注意：英文区分大小写）
 回答正确

Listbox
正确答案
Listbox [或者]列表框
解析
Listbox（列表框）用于显示对象列表，并且允许用户选择一个或多个项。

+ 3.0 分
29 . 填空题 简单 3分
______________允许用户选择一个项的列表框（在用户请求时显示）。用户单击下拉按钮可显示列表框，选择的内容会显示在顶部文本框中。（注意：英文区分大小写）
 回答正确

OptionMenu
正确答案
OptionMenu [或者]选择项
解析
OptionMenu（选择项）允许用户选择一个项的列表框（在用户请求时显示）。用户单击下拉按钮可以显示列表框，选择的内容会显示在顶部文本框中。

+ 3.0 分
30 . 填空题 简单 3分
______________控件用于在有界区间内，通过移动滑块来选择值。（注意：英文区分大小写）
 回答正确

Scale
正确答案
Scale [或者]移动滑块
解析
Scale（移动滑块）控件用于在有界区间内，通过移动滑块来选择值。

+ 2.0 分
31 . 填空题 简单 2分
tkinter模块中的子模块_________、_________、_________和_________，包括通用的预定义对话框；用户也可以通过继承TopLevel创建自定义对话框。（注意：英文区分大小写）
 回答正确

messagebox、filedialog、colorchooser、simpledialog
正确答案
messagebox、filedialog、colorchooser、simpledialog
解析
tkinter模块中的子模块messagebox、filedialog、colorchooser、simpledialog，包括一些通用的预定义对话框；用户也可以通过继承TopLevel创建自定义对话框。

+ 2.0 分
32 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现通用消息对话框的功能。（注意：英文区分大小写）
 回答正确

messagebox
正确答案
messagebox
解析
模块tkinter的子模块messagebox包含若干用于打开消息对话框的函数。

+ 2.0 分
33 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现文件对话框的功能。（注意：英文区分大小写）
 回答正确

filedialog
正确答案
filedialog
解析
模块tkinter的子模块filedialog包含若干用于打开文件对话框的函数。

+ 2.0 分
34 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现颜色选择对话框的功能。（注意：英文区分大小写）
 回答正确

colorchooser
正确答案
colorchooser
解析
模块tkinter的子模块colorchooser包含用于打开颜色选择对话框的函数。

+ 2.0 分
35 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现输入对话框的功能。（注意：英文区分大小写）
 回答正确

simpledialog
正确答案
simpledialog
解析
模块tkinter的子模块simpledialog中包含若干用于打开输入对话框的函数。
第8章平时作业
1 . 单选题 简单 9分
在DBMS中，如果一个国家只能有一个总统，而一个总统只能在一个国家任职，则国家和总统为（      ）的联系。
A.
一对一
B.
一对多
C.
多对多
D.
多对一
 回答正确

A
正确答案
A
解析

+ 9.0 分
2 . 单选题 简单 9分
在DBMS中，如果一个部门有多名员工，而一名员工只能在一个部门工作，则部门和员工为（      ）的联系。
A.
一对一
B.
一对多
C.
多对多
D.
多对一
 回答正确

B
正确答案
B
解析

+ 9.0 分
3 . 单选题 简单 9分
在DBMS中，如果一名学生可以选修多门课程，而一门课程可以有多名选修的学生，则学生和课程是（      ）的联系。
A.
一对一
B.
一对多
C.
多对多
D.
多对一
 回答正确

C
正确答案
C
解析

+ 9.0 分
4 . 单选题 简单 9分
在DBMS中，假设有表示学生选课的三张表，其中学生S（学号，姓名，性别，年龄，身份证号），课程C（课号，课名），选课SC（学号，课号，成绩），则选课表SC的关键字（键或码）为（      ）。
A.
学号，课号
B.
学号，成绩
C.
课号，成绩
D.
学号，姓名，成绩
 回答正确

A
正确答案
A
解析

+ 8.0 分
5 . 单选题 简单 8分
在DBMS中，假设有表示公司和职员及工作的三张表，职员可在多家公司兼职。其中公司C（公司号，公司名，地址，注册资本，法人代表，员工数），职员S（职员号，姓名，性别，年龄，学历），工作W（公司号，职员号，工资），则工作表W的关键字（键或码）为（      ）。
A.
公司号，职员号，工资
B.
职员号
C.
职员号，工资
D.
公司号，职员号
 回答正确

D
正确答案
D
解析

+ 0.0 分
6 . 填空题 简单 8分
数据库管理系统的主要功能包括___________、___________和___________。
 回答错误

数据定义、数据操作、数据库运行控制
正确答案
数据定义功能、数据操作功能、数据库的管理和维护
解析

+ 0.0 分
7 . 填空题 简单 8分
现实世界的数据可以抽象为___________，也称为___________。
 回答错误

实体、对象
正确答案
概念模型（Conceptual Model）[或者]概念模型[或者]Conceptual Model、信息模型
解析

+ 8.0 分
8 . 填空题 简单 8分
实体是指现实世界中具有一定特征或属性并与其它实体有联系的对象，在关系模型中实体通常是以________的形式来表现。
 回答正确

表
正确答案
表[或者]数据表
解析

+ 8.0 分
9 . 填空题 简单 8分
SQLite是遵守________的关系数据库管理系统。
 回答正确

ACID
正确答案
ACID [或者]原子性Atomicity、一致性Consistency、隔离性Isolation、持久性Durability[或者]原子性、一致性、隔离性、持久性[或者] Atomicity、Consistency、Isolation、Durability
解析

+ 0.0 分
10 . 填空题 简单 8分
在E-R图中用来表示实体联系的图形是________。
 回答错误

菱形
正确答案
矩形框
解析

+ 2.0 分
11 . 简答题 困难 8分
题目：创建一个数据库stuinfo，并在其中创建数据库表student，表中包含stuid(学号)、stuname（姓名）、birthday（出生日期）、sex（性别）、address（家庭地址）、rxrq（入学日期）6列，其中stuid设为主键，并添加5条记录。
将所有记录的rxrq属性更新为2017-9-1。
查询性别为“女”的所有学生的stuname和address字段值。
 回答正确

import sqlite3
# 创建数据库stuinfo
conn = sqlite3.connect('stuinfo.db')
cursor = conn.cursor()
# 创建student表
create_table_query = '''
    CREATE TABLE IF NOT EXISTS student (
        stuid INTEGER PRIMARY KEY,
        stuname TEXT,
        birthday DATE,
        sex TEXT,
        address TEXT,
        rxrq DATE
    )
'''
cursor.execute(create_table_query)
conn.commit()
# 插入5条记录
insert_data_query = '''
    INSERT INTO student (stuid, stuname, birthday, sex, address, rxrq)
    VALUES (?, ?, ?, ?, ?, ?)
'''
data_to_insert = [
    (1, '张三', '2000-01-01', '男', '北京市', '2017-08-31'),
    (2, '李四', '1999-05-11', '女', '上海市', '2017-09-01'),
    (3, '王五', '2001-03-20', '男', '广州市', '2017-09-02'),
    (4, '赵六', '1998-11-05', '女', '深圳市', '2017-09-01'),
    (5, '陈七', '2002-09-15', '男', '成都市', '2017-09-01')
]
cursor.executemany(insert_data_query, data_to_insert)
conn.commit()
# 将所有记录的rxrq属性更新为2017-09-01
update_query = '''
    UPDATE student
    SET rxrq = '2017-09-01'
'''
cursor.execute(update_query)
conn.commit()
# 查询性别为“女”的所有学生的stuname和address字段值
query = '''
    SELECT stuname, address
    FROM student
    WHERE sex = '女'
'''
cursor.execute(query)
results = cursor.fetchall()
for row in results:
    stuname, address = row
    print("姓名：", stuname)
    print("地址：", address)
# 关闭连接
conn.close()
正确答案
import sqlite3
con=sqlite3.connect("sales.db")
cur=con.cursor()
cur.execute("DROP table book")#第一次运行时这句删掉，之后再运行加上。
con.execute("create table book(stuid primary key,stuname varchar(20),birthday integer(20),sex varchar(20),address varchar(20),rxrq integer(20))")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (1,'张一',19980301,'男','黄河路1号',20160901)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (2,'张二',19980302,'女','黄河路2号',20160902)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (3,'张三',19980303,'男','黄河路3号',20160903)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (4,'张四',19980304,'男','黄河路4号',20160904)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (5,'张五',19980305,'女','黄河路5号',20160905)")
print('记录计入完成')
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('记录更新完成')
cur.execute("Update book set rxrq=20170901")
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('性别为女的名字和地址信息为：')
cur.execute('select stuname,sex,address from book')
values = cur.fetchall()
for row in values:
    if row[1]=='女':
print(row[0],row[2])
cur.close()
con.commit()
con.close()
 
解析

+ 2.0 分
12 . 简答题 中等 8分
创建一个数据库stuinfo，并在其中创建数据库表student，表中包含stuid(学号)、stuname（姓名）、birthday（出生日期）、sex（性别）、address（家庭地址）、rxrq（入学日期）6列，其中stuid设为主键，并添加5条记录。
将所有记录的rxrq属性更新为2017-9-1。
查询性别为“女”的所有学生的stuname和address字段值。
 回答正确

import sqlite3
# 创建数据库stuinfo
conn = sqlite3.connect('stuinfo.db')
cursor = conn.cursor()
# 创建student表
create_table_query = '''
  CREATE TABLE IF NOT EXISTS student (
    stuid INTEGER PRIMARY KEY,
    stuname TEXT,
    birthday DATE,
    sex TEXT,
    address TEXT,
    rxrq DATE
  )
'''
cursor.execute(create_table_query)
conn.commit()
# 插入5条记录
insert_data_query = '''
  INSERT INTO student (stuid, stuname, birthday, sex, address, rxrq)
  VALUES (?, ?, ?, ?, ?, ?)
'''
data_to_insert = [
  (1, '张三', '2000-01-01', '男', '北京市', '2017-08-31'),
  (2, '李四', '1999-05-11', '女', '上海市', '2017-09-01'),
  (3, '王五', '2001-03-20', '男', '广州市', '2017-09-02'),
  (4, '赵六', '1998-11-05', '女', '深圳市', '2017-09-01'),
  (5, '陈七', '2002-09-15', '男', '成都市', '2017-09-01')
]
cursor.executemany(insert_data_query, data_to_insert)
conn.commit()
# 将所有记录的rxrq属性更新为2017-09-01
update_query = '''
  UPDATE student
  SET rxrq = '2017-09-01'
'''
cursor.execute(update_query)
conn.commit()
# 查询性别为“女”的所有学生的stuname和address字段值
query = '''
  SELECT stuname, address
  FROM student
  WHERE sex = '女'
'''
cursor.execute(query)
results = cursor.fetchall()
for row in results:
  stuname, address = row
  print("姓名：", stuname)
  print("地址：", address)
# 关闭连接
conn.close()
正确答案
代码：
import sqlite3
con=sqlite3.connect("sales.db")
cur=con.cursor()
cur.execute("DROP table book")#第一次运行时这句删掉，之后再运行加上。
con.execute("create table book(stuid primary key,stuname varchar(20),birthday integer(20),sex varchar(20),address varchar(20),rxrq integer(20))")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (1,'张一',19980301,'男','黄河路1号',20160901)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (2,'张二',19980302,'女','黄河路2号',20160902)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (3,'张三',19980303,'男','黄河路3号',20160903)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (4,'张四',19980304,'男','黄河路4号',20160904)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (5,'张五',19980305,'女','黄河路5号',20160905)")
print('记录计入完成')
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
    print(row)
print('记录更新完成')
cur.execute("Update book set rxrq=20170901")
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
    print(row)
print('性别为女的名字和地址信息为：')
cur.execute('select stuname,sex,address from book')
values = cur.fetchall()
for row in values:
    if row[1]=='女':
     print(row[0],row[2])
cur.close() 
con.commit() 
con.close()
第9章平时作业
1 . 简答题 中等 4分
TCP协议和UDP协议的主要区别是什么？
 回答正确

TCP和UDP都是网络传输层协议，但是它们有以下几个主要区别： 可靠性方面：TCP提供可靠的数据传输，UDP不保证可靠的数据传输。连接方面：TCP是面向连接的协议，UDP是无连接的协议。 速度方面：UDP传输速度快，TCP传输速度较慢
正确答案
TCP协议建立在IP协议之上，负责在两台计算机之间建立可靠连接，保证数据包按顺序到达。TCP协议会通过握手建立连接，然后，对每个IP包编号，确保对方按顺序收到。如果包丢掉了，就自动重发。
UDP协议也建立在IP协议之上，但是UDP协议是面向无连接的通信协议，不保证数据包的顺利到达，不可靠传输。所以效率比TCP要高。
使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。虽然用UDP传输数据不可靠，但它的优点是和TCP相比，速度快，对于不要求可靠到达的数据，就可以使用UDP协议。
解析

+ 1.0 分
2 . 简答题 中等 4分
Socket有什么用途？
 回答正确

套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合
正确答案
socket 用来写网络通讯程序的，简单来说在远程机器（服务器）和本地机器各建一个socket，然后即可进行连接通讯。
Socket非常类似于电话插座。以一个国家级电话网为例，电话的通话双方相当于相互通信的2个进程，区号是它的网络地址;分配给每个用户的电话号码相当于Socket号。任何用户在通话之前，首先要占有一部电话机，相当于申请一个Socket;同时要知道对方的号码，相当于对方有一个固定的Socket。然后向对方拨号呼叫，相当于发出连接请求(假如对方不在同一区内，还要拨对方区号，相当于给出网络地址)。假如对方在场并空闲(相当于通信的另一主机开机且可以接受连接请求)，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向Socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭Socket，撤消连接。
解析

+ 1.0 分
3 . 简答题 困难 4分
简单描述开发UDP程序的过程。
 回答正确

开发UDP程序的过程可以分为以下几个步骤：
1,创建Socket：使用编程语言提供的Socket API，创建一个UDP Socket对象。UDP是一种无连接的协议，所以不需要在客户端和服务器端都建立连接。
2,绑定地址和端口：将Socket绑定到一个本地地址和端口上。这样可以确保接收到发送到该地址和端口的UDP数据包。
3,接收数据：使用Socket的接收方法从网络中接收UDP数据包。可以使用循环来持续接收数据，或者设置超时时间以避免阻塞。
4,处理数据：对接收到的数据进行处理，根据自己的需求解析数据内容。
5,发送数据：使用Socket的发送方法将数据发送到目标地址和端口。可以直接指定目标地址，也可以通过DNS解析获取目标地址。
6,关闭Socket：在程序结束或不再需要使用Socket时，调用关闭方法释放资源。
正确答案
python udp是无连接，没有TCP的三次握手，错误重传机制，发的只管发，收的只管收，效率比TCP高，运用于对数据帧不高的地方，如视频，音频的传输。
一、实现过程:
服务器端过程如下:
1.建立UDP的SOCKET
2.绑定一个接口，让客户端连接
3.接受数据
客户端过程如下:
1.创建一个socket
2.收发数据报
二、代码实现
1.服务器端：
import socket
from time import ctime
def udpServer():
buffer=2048
address=('127.0.0.1',8080) 
udpsock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udpsock.bind(address)
    while True:    #不断循环
print ('wait for message...')
        data,addr=udpsock.recvfrom(buffer)         #接受数据
        str='[%s]%s' %(ctime(),data.decode('utf-8'))
        udpsock.sendto(str.encode('utf-8'),addr) #发送数据
print ('...received from and retuned to:',addr)
udpsock.close()
if __name__=='__main__':
udpServer()
2.客户端:
import socket
def udpClient():
address=('localhost',8080)
    udpClientSocket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #创建socket
    while True:   #不断循环
data= input('>')
if not data:
break
        udpClientSocket.sendto(data.encode('utf-8'),address) #发送数据
data,addr=udpClientSocket.recvfrom(2048)
print (data.decode('utf-8'))
udpClientSocket.close()
if __name__=='__main__':
udpClient()
运行结果：
服务器端：
wait for message...
...received from and retuned to: ('127.0.0.1', 61957)
wait for message...
...received from and retuned to: ('127.0.0.1', 61957)
wait for message...
客户端:
>中国
[Sat Mar 24 10:35:19 2018]中国
>hello
[Sat Mar 24 10:35:29 2018]hello
>
解析

+ 2.0 分
4 . 简答题 困难 4分
编写获取本机IP的程序。
 回答正确

import socket
def get_local_ip():
 try:
  s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  s.connect(('8.8.8.8', 80))
  ip = s.getsockname()[0]
 except Exception as e:
  print("获取本机IP地址失败", e)
  ip = None
 finally:
  s.close()
 return ip
if __name__ == '__main__':
 print(get_local_ip())
正确答案
import socket
myname = socket.getfqdn(socket.gethostname( ))#获取本机电脑名
myaddr = socket.gethostbyname(myname)#获取本机ip
print(myname,myaddr)
import uuid
#python 获得本机MAC地址：
def get_mac_address(): 
mac=uuid.UUID(int = uuid.getnode()).hex[-12:] 
return ":".join([mac[e:e+2] for e in range(0,11,2)])
print("本机MAC地址:",get_mac_address())
#方法二：
#利用 UDP 协议来实现的，生成一个UDP包，
#把自己的 IP 放如到 UDP 协议头中，然后从UDP包中获取本机的IP。
#封装成函数，方便 Python 的程序调用
import socket
def get_host_ip():
try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 80))  #
ip = s.getsockname()[0]
finally:
s.close()
return ip
print( get_host_ip())  #'192.168.1.105' 
解析

+ 1.0 分
5 . 填空题 简单 4分
TCP/IP协议模型把TCP/IP协议族分成四个层次：_________、_________、_________和_________。
 回答正确

应用层、网络层、传输层、数据链路层
正确答案
网络接口层、Internet层、传输层、应用层
解析
TCP/IP协议，即传输控制协议/互连网协议，是一种网际互联通信协议，其目的在于通过它实现网际间各种异构网络和异种计算机的互联通信。

+ 4.0 分
6 . 填空题 简单 4分
Internet采用一种全局通用的地址格式，为网络中的每一台主机都分配一个唯一的地址，称为____________。
 回答正确

IP地址
正确答案
IP地址
解析

+ 4.0 分
7 . 填空题 简单 4分
Internet使用____________来管理计算机域名与IP地址的对应关系。（注意：英文区分大小写）
 回答正确

DNS
正确答案
域名系统  [或者]Domain Name System  [或者]DNS
解析

+ 4.0 分
8 . 填空题 简单 4分
IP地址用来标识Internet上的主机，而位于Internet主机上的资源（如各种文档、图像等）则通过____________来标识。（注意：英文区分大小写）
 回答正确

URL
正确答案
统一资源定位器   [或者]Uniform Resource Locator   [或者]URL
解析
URL（Uniform Resource Locator，统一资源定位器）是专为标识Internet网上资源位置而设的一种编址方式。。

+ 4.0 分
9 . 填空题 简单 4分
TCP/IP协议的传输层包含两个传输协议：面向连接的_________和非面向连接的_________。（注意：英文区分大小写）
 回答正确

TCP、UDP
正确答案
TCP、UDP
解析

+ 0.0 分
10 . 填空题 简单 4分
创建服务器端socket对象并绑定到IP地址后，可以使用_________和_________对象方法进行侦听和接收连接。（注意：英文区分大小写）
 回答错误

listen()、accept()
正确答案
listen、accept
解析

+ 0.0 分
11 . 填空题 简单 4分
客户机端socket对象通过____________方法尝试建立到服务器端socket对象的连接。（注意：英文区分大小写）
 回答错误

connect()
正确答案
connect
解析

+ 4.0 分
12 . 单选题 简单 4分
在Python多线程和并行计算相关的主要模块中，（      ）模块提供基于进程的并行功能。
A.
multiprocessing
B.
threading
C.
concurrent
D.
queue 
 回答正确

A
正确答案
A
解析

+ 4.0 分
13 . 单选题 简单 4分
在Python多线程和并行计算相关的主要模块中，（      ）模块提供底层多线程API功能。
A.
_thread
B.
threading
C.
concurrent
D.
queue
 回答正确

A
正确答案
A
解析

+ 4.0 分
14 . 单选题 简单 4分
在Python网络和进程间通信相关的主要模块中，（      ）模块提供底层网络接口功能。
A.
asyncio
B.
ssl
C.
socket
D.
signal
 回答正确

C
正确答案
C
解析

+ 0.0 分
15 . 单选题 简单 4分
在Python中运行以下程序产生的输出结果是（      ）。
import time
t = time.gmtime()
print(time.strftime("%Y-%m-%d %H:%M:%S",t))
A.
系统当前的日期与时间
B.
系统当前的日期
C.
系统当前的时间
D.
系统出错
 回答错误

C
正确答案
A
解析

+ 0.0 分
16 . 单选题 简单 4分
如果当前时间是2022年5月1日10点10分9秒，则如下Python代码的输出结果是（      ）。
import time
print(time.strftime("%Y=%m-%d@%H>%M>%S", time.gmtime()))
A.
2022=05-01@10>10>09
B.
2022=5-1 10>10>9
C.
True@True
D.
2022=5-1@10>10>9 
 回答错误

D
正确答案
A
解析

+ 4.0 分
17 . 单选题 简单 4分
执行如下Python代码后，描述错误的选项是（      ）。
import time
print(time.time());time.sleep(5)
A.
输出自1970年1月1日00:00:00 AM以来的秒数
B.
time模块是Python的标准库
C.
可以使用time.ctime()代替time.time()，显示为更具可读性的日期时间格式
D.
time.sleep(5)推迟调用线程的运行，单位为毫秒
 回答正确

D
正确答案
D
解析

+ 0.0 分
18 . 填空题 简单 4分
使用time模块的____________函数可以获取当前系统的起始点。（注意：英文区分大小写）
 回答错误

time()
正确答案
getime
解析

+ 4.0 分
19 . 填空题 简单 4分
time模块中的___________函数将字符串解析为struct_time对象；___________函数将struct_time对象格式化为字符串。（注意：英文区分大小写）
 回答正确

strptime()、strftime()
正确答案
strptime()、strftime()
解析

+ 0.0 分
20 . 填空题 简单 3分
Python中的____________模块包含用于处理时间的函数。（注意：英文区分大小写）
 回答错误

datetime
正确答案
time
解析

+ 3.0 分
21 . 单选题 简单 3分
Python语句print(type(lambda:None))的输出结果是（      ）。
A.
<class 'NoneType'>
B.
<class 'tuple'>
C.
<class 'type'>
D.
<class 'function'>
 回答正确

D
正确答案
D
解析
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。

+ 3.0 分
22 . 单选题 简单 3分
Python语句序列“f = lambda x,y: x * y; f(12, 34)”的程序运行结果是（      ）。
A.
12
B.
22
C.
56
D.
408
 回答正确

D
正确答案
D
解析
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。

+ 3.0 分
23 . 单选题 简单 3分
Python语句序列“f1=lambda x:x*2; f2= lambda x:x**2; print(f1(f2(2)))”的程序运行结果是（      ）。
A.
2
B.
4
C.
6
D.
8
 回答正确

D
正确答案
D
解析
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。

+ 3.0 分
24 . 填空题 简单 3分
下列Python语句的输出结果是___________。
d = lambda p: p * 2; t = lambda p: p * 3
x = 2;x = d(x);x = t(x);x = d(x);print(x)
 回答正确

24
正确答案
24
解析
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。

+ 3.0 分
25 . 填空题 简单 3分
下列Python语句的输出结果是___ ______、_________、_________。
i = map(lambda x: x**2, (1, 2, 3))
for t in i: print(t, end=' ')
 回答正确

1、4、9
正确答案
1、4、9
解析
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。

+ 3.0 分
26 . 编程题 中等 3分
return语句求最大值
 回答正确
编写程序，利用函数的return语句返回函数值，求若干数中的最大值。测试数据是求1、7、11、2、5中的最大值。

def find_max(*args):
    max_value = max(args)
    return max_value
result = find_max(1, 7, 11, 2, 5)
print(result)
正确答案
def my_max(a, b, *c): #求若干数中的最大值
    max_value = a  #假设第一个数为最大值
    if max_value < b: #如果最大值小于b，则b为最大值
        max_value = b
    for n in c:      #循环迭代c中每个元素n，如果最大值小于n，则n为最大值
        if max_value < n:
            max_value = n
    return max_value  #利用return语句返回最大值
#测试代码
print(my_max(1, 7, 11, 2, 5))  #求(1, 7, 11, 2, 5)中的最大值
解析
求若干数中最大值的方法一般如下：
（1）将最大值的初值设为一个比较小的数，或者取第一个数为最大值的初值。
（2）利用循环，将每个数与最大值比较，若此数大于最大值，则将此数设置为最大值。

+ 3.0 分
27 . 编程题 中等 3分
素数
 回答正确
编写程序，先编制一个判断一个数是否为素数的函数，然后编写测试代码，判断并输出1~99中的素数。

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True
for i in range(1, 100):
    if is_prime(i):
        print(i,end=" ")
正确答案
def is_prime(n):
    if n < 2: return False  #如果n小于2，返回False
    i = 2
    while i*i <= n:
        #一旦n能够被2~ 中的任意整数整除，n就不是素数，返回False
        if n % i == 0: return False 
        i += 1
    return True
#测试代码
for i in range(100):  #判断并输出1~99中的素数，以空格分隔
    if is_prime(i):print(i, end=' ')
解析
所谓素数（或称质数），是指除了1和该数本身，不能被任何整数整除的正整数。判断一个正整数n是否为素数，只要判断n可否被2~ 之中的任何一个整数整除，如果n不能被此范围中任何一个整数整除，n即为素数，否则n为合数。
第11章文本处理
1 . 单选题 简单 6分
在Python文本处理相关的主要模块中，（         ）模块主要提供处理正则表达式的对象和函数。
A.
re
B.
string
C.
textwrap
D.
stringprep
 回答正确

A
正确答案
A
解析

+ 4.0 分
2 . 填空题 简单 6分
Python中文分词组件jieba支持三种分词模式，即_______、______和______。
 回答正确

精准模式、全模式、搜索引擎模式
正确答案
精确模式、全模式、搜索引擎模式
解析

+ 0.0 分
3 . 填空题 简单 6分
Python语句re.match('back', 'text.back')的执行结果是___________。
 回答错误

none
正确答案
空
解析

+ 6.0 分
4 . 填空题 简单 6分
Python语句re.findall("to", "Tom likes to swim too")的执行结果是___________。（注意：英文区分大小写）
 回答正确

['to', 'to']
正确答案
['to', 'to']
解析

+ 6.0 分
5 . 填空题 简单 6分
Python语句re.findall("bo[xy]", "The boy is sitting on the box")的执行结果是___________。（注意：英文区分大小写）
 回答正确

['boy', 'box']
正确答案
['boy', 'box']
解析

+ 0.0 分
6 . 填空题 简单 6分
中华人民共和国邮政编码由6位数字组成，使用重复限定符___________，表示数字字母重复6次。
 回答错误

{6}
正确答案
\d{6}
解析

+ 0.0 分
7 . 填空题 简单 6分
正则表达式引擎均支持不同的匹配模式，也称之为匹配选项，其中，__________使正则表达式对大小写不敏感，__________开启多行模式。（注意：英文区分大小写）
 回答错误

(?!)、(?m)
正确答案
/i、/m
解析

+ 0.0 分
8 . 填空题 简单 6分
Python语句re.sub('hard', 'easy', 'Python is hard to learn.')的执行结果是___________。（注意：英文区分大小写）
 回答错误

Python is easy to learn.
正确答案
'Python is easy to learn.'
解析

+ 6.0 分
9 . 填空题 简单 6分
Python语句re.split('\W+', 'go, went, gone')的执行结果是___________。（注意：英文区分大小写）
 回答正确

['go', 'went', 'gone']
正确答案
['go', 'went', 'gone']
解析

+ 6.0 分
10 . 填空题 简单 6分
Python语句re.split('\d', 'a1b2c3')的执行结果是___________。（注意：英文区分大小写）
 回答正确

['a', 'b', 'c', '']
正确答案
['a', 'b', 'c', '']
解析

+ 5.0 分
11 . 填空题 简单 5分
下列Python语句的输出结果是_____。
import re; sum = 0; pattern = 'boy'
if re.match(pattern, 'boy and girl'): sum += 1
if re.match(pattern, 'girl and boy'): sum += 2
if re.search(pattern, 'boy and girl'): sum += 3
if re.search(pattern, 'girl and boy'): sum += 4
print(sum)
 回答正确

8
正确答案
8
解析
注意，match函数从字符串头部开始匹配，而search函数在字符串任何位置匹配。

+ 3.3 分
12 . 填空题 简单 5分
下列Python语句的输出结果是__________、__________、__________。（注意：英文区分大小写）
import re
re.match("to", "Tom likes to swim too")
re.search("to", "Tom likes to swim too"); 
re.findall("to", "Tom likes to swim too")
 回答正确

None、<re.Match object; span=(4, 6), match='to'>、['to', 'to']
正确答案
None、<re.Match object; span=(10, 12), match='to'>、['to', 'to']
解析

+ 5.0 分
13 . 填空题 简单 5分
下列Python语句的输出结果是_____。（注意：英文区分大小写）
import re; m = re.search("to", "Tom likes to swim too")
print(m.group(),m.span())
 回答正确

to (10, 12)
正确答案
to (10, 12)
解析

+ 0.0 分
14 . 填空题 简单 5分
以十三届全国人大四次会议报告中一句话“依靠创新推动实体经济高质量发展，培育壮大新动能。”作为字符串变量s，完善以下Python程序，分别使用Python内置函数及jieba库中已有函数统计字符串s的中文字符个数及中文词语个数。注意，中文字符包含中文标点符号。
import jieba
s = "依靠创新推动实体经济高质量发展，培育壮大新动能。"
n = ___________
m = ___________
print("中文字符数为{}，中文词语数为{}".format(n, m))
 回答错误

len([c for c in s if '\u4e00' <= c <= '\u9fff'])、len([w for w in list(jieba.cut(s)) if '\u4e00' <= w <= '\u9fff'])
正确答案
len(s)、len(jieba.lcut(s))
解析

+ 5.0 分
15 . 编程题 中等 5分
电子邮件格式
 回答正确
编写程序，验证一个字符串是否为有效的电子邮件格式。

import re
def is_valid_email(email):
    # 定义电子邮件的正则表达式模式
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    
    # 使用re模块的match函数进行匹配
    if re.match(pattern, email):
        return True
    else:
        return False
# 测试
email1 = 'abc@example.com'
email2 = 'invalid_email'
email3 = 'test@123.45'
print("请输入电子邮箱：{}".format(is_valid_email(email1)))  # 输出：True
正确答案
import os, re
def check_email(strEmail):
    regex_email = re.compile(r'^[\w\.\-]+@([\w\-]+\.)+[\w\-]+$')
    result = True if regex_email.match(strEmail) else False
    return result
#测试代码
if __name__=='__main__':
    str1 = input("请输入电子邮箱：")
    print( check_email(str1))
解析
通过正则表达式re模块的匹配和搜索，或者正则表达式对象的匹配和搜索，可以验证一个字符串是否与指定模式匹配，即实现字符串包含验证。

+ 5.0 分
16 . 单选题 简单 5分
下列数据类型中，Python不支持的是（      ）。
A.
char
B.
int
C.
float
D.
list
 回答正确

A
正确答案
A
解析
无。

+ 5.0 分
17 . 单选题 简单 5分
关于Python字符串，下列说法错误的是（      ）。
A.
字符即长度为1的字符串
B.
字符串以\0标志字符串的结束
C.
用户既可以用单引号，也可以用双引号创建字符串
D.
在三引号字符串中可以包含换行回车等特殊字符
 回答正确

B
正确答案
B
解析
Python字符串字面量可以使用以下单引号、双引号、三单引号、三双引号四种方式定义。Python中没有独立的字符数据类型，字符即长度为1的字符串

+ 5.0 分
18 . 简答题 简单 5分
下列Python语句的输出结果是______。
print("数量{0}，单价{1}".format(100, 285.6))
print(str.format("数量{0}，单价{1:3.2f}", 100, 285.6))
print("数量%4d，单价%3.3f" % (100, 285.6))
 回答正确

数量100，单价285.6
数量100，单价285.60
数量 100，单价 285.600
正确答案
数量100，单价285.6、数量100，单价285.60、数量 100，单价285.600
解析