Python语言程序设计（北京理工大学）第五周_Python Programming week05

1. 以下关于递归函数基例的说法错误的是：

A. 每个递归函数都只能有一个基例

B. 递归函数的基例决定递归的深度

C. 递归函数的基例不再进行递归

D. 递归函数必须有基例

每个递归函数至少存在一个基例，但可能存在多个基例。

2. 以下选项不是函数作用的是：

A. 复用代码

B. 降低编程复杂度

C. 提高代码执行速度

D. 增强代码可读性

函数不能直接提高代码执行速度。

3. 下列程序的输出结果为：

def f(a,b):
  a=4
  return  a+b
def main():
  a=5
  b=6
  print(f(a,b),a+b)
main()

A. 10 11

B. 11 11

C. 11 10

D. 10 10

这里没有全局变量，都是函数局部变量的运算。

4. 以下关于Python函数说法错误的是：

def func(a,b):
  c=a**2+b
  b=a
  return c
a=10
b=100
c=func(a,b)+a

A. 执行该函数后，变量a的值为10

B. 执行该函数后，变量b的值为100

C. 执行该函数后，变量c的值为200

D. 该函数名称为func

这里没有全局变量，请在IDLE中执行代码观察结果。

5. 以下关于函数调用描述正确的是：

A. 函数在调用前不需要定义，拿来即用就好

B. 自定义函数调用前必须定义

C. 函数和调用只能发生在同一个文件中

D. Python内置函数调用前需要引用相应的库

函数调用前必须已经存在函数定义，否则无法执行。

Python内置函数直接使用，不需要引用任何模块。

6. 以下关于模块化设计描述错误的是：
A. 应尽可能合理划分功能块，功能块内部耦合度低
B. 高耦合度的特点是复用较为困难
C. 应尽可能合理划分功能块，功能块内部耦合度高
D. 模块间关系尽可能简单，模块之间耦合度低

模块内高耦合、模块间低耦合。

7. 以下对递归描述错误的是：
A. 书写简单
B. 一定要有基例
C. 执行效率高
D. 递归程序都可以有非递归编写方法
递归不提高程序执行效率。
任何递归程序都可以通过堆栈或队列变成非递归程序（这是程序的高级应用）。

8. 以下关于函数说法错误的是：
A. ‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪函数可以看做是一段具有名字的子程序
B. 函数是一段具有特定功能的、可重用的语句组
C. 对函数的使用必须了解其内部实现原理
D. 函数通过函数名来调用
调用函数不需要知道函数内部实现原理，只需要知道调用方法（即接口）即可。

9. 哪个选项对于函数的定义是错误的？
A. def vfunc(a,b=2):
B. def vfunc(a,*b):
C. def vfunc(a,b):
D. def vfunc(*a,b):
def vfunc(*a, b) 是错误的定义：*a表示可变参数，可变参数只能放在函数参数的最后。

10. 关于return语句，以下选项描述正确的是：
A. 函数必须有一个return语句
B. 函数可以没有return语句
C. 函数中最多只有一个return语句
D. return只能返回一个值
函数可以包含0个或多个return语句

 

 

 

# funct.py
# n!//m
def fact(n, m=1):
    s = 1
    for i in range(1, n+1):
        s *= i
    return s//m
print("fact(3): {}".format(fact(3)))
print("fact(3,1): {}".format(fact(3,1)))
print("fact(m=1, n=3): {}".format(fact(m=1, n=3)))

====================== RESTART: D:\2018\python\funct.py ======================
fact(3): 6
fact(3,1): 6
fact(m=1, n=3): 6

# funct2.py
# n!乘数
def fact(n, *b):
    s = 1
    for i in range(1, n+1):
        s *= i
    for item in b:
        s *= item
    return s
print("fact(3): {}".format(fact(3)))
print("fact(3, 3): {}".format(fact(3, 3)))
print("fact(3, 3,5,7,9): {}".format(fact(3, 3,5,7,9)))

===================== RESTART: D:/2018/python/funct2.py =====================
fact(3): 6
fact(3, 3): 18
fact(3, 3,5,7,9): 5670

# funct3.py
# n!//m
def fact(n, m=1):
    s = 1
    for i in range(1, n+1):
        s *= i
    return s//m, n, m
print("fact(10,5): {}".format(fact(10,5)))
a,b,c = fact(10,5)
print("a,b,c: {},{},{}".format(a,b,c))

===================== RESTART: D:/2018/python/funct3.py =====================
fact(10,5): (725760, 10, 5)
a,b,c: 725760,10,5

# global.py
n, s = 10, 100
def fact1(n):
    s = 100
    for i in range(1, n+1):
        s *= i
    return s
def fact2(n):
    global s
    for i in range(1, n+1):
        s *= i
    return s
print(fact1(n), s)
print(fact2(n), s)

===================== RESTART: D:\2018\python\global.py =====================
362880000 100
362880000 362880000

# ls.py
ls = ["F", "f"]
def func(a):
    ls.append(a)
    return
func("C")
print(ls)

======================= RESTART: D:\2018\python\ls.py =======================
['F', 'f', 'C']

# ls.py
ls = ["F", "f"]
def func(a):
    ls = []
    ls.append(a)
    return
func("C")
print(ls)

======================= RESTART: D:/2018/python/ls2.py =======================
['F', 'f']

>>> f = lambda x,y: x+y
>>> f(10,15)
25
>>> f = lambda : "lambda function"
>>> print(f())
lambda function

>>> s = "python is good"
>>> s[::-1]
'doog si nohtyp'

# reverse_string.py
def rvs(s):
    if s == "":
        return s
    else:
        return rvs(s[1:]) + s[0]
print(rvs("python is good"))

================= RESTART: D:\2018\python\reverse_string.py =================
doog si nohtyp