020--python函数基础知识考试(包括：函数_递归等知识）
1、列举布尔值为 False 的值
空，None，0, False, '', [], {}, ()
2、写函数：
根据范围获取其中 3 和 7 整除的所有数的和，并返回调用者：符合条件的数字个数以及符合条件的数字的总和
如： def func(start,end):
def func(start,end,count=0):
s=0
for i in range(start,end+1):
if i%3==0 and i%7==0:
s+=i
count+=1
print('总和:%s 个数：%s'%(s,count))
func(1,100)
#输出 总和:210 个数：4
3、函数的默认返回值是什么？
None
4、简述break/continue/return的区别
break 结束当前层循环
continue 结束本次循环
return 作为函数运行结束标志
5、函数传递参数时，是引用还是复制值？并证明提示：可以用 id 进行判断
传引用
def fib(n):
print('函数中',id(n))
n=5
print('函数外',id(n))
fib(5)
输出：
函数外 1729344704
函数中 1729344704
6、简述三元运算书写格式以及应用场景
c = a if a<b else b
7、简述 lambda 表达式书写格式以及应用场景
lambda n:n**2 适用于逻辑运算简单的函数
8、使用 set 集合获取两个列表l1=[11,22,33],l2=[22,33,44]中相同的元素集合
n1=set（l1） n2=set（l2） res=n1.intersation（n2）
9、定义函数统计一个字符串中大写字母、小写字母、数字的个数，并以字典为结果返回给调用者
def fib(stre):
count1,count2,count3=0,0,0
for i in stre:
if i.isupper():
count1+=1
if i.islower():
count2+=1
if i.isdigit():
count3+=1
return ({'大写字母':count1,'小写字母':count2,'数字':count3})
res = fib('ASDfg1')
print(res)
10、简述函数的位置参数、关键字参数、默认参数、可变长参数的特点以及注意事项
位置参数：按照对应形参位置一一对应传入参数，普通参数
关键字参数：允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
默认参数：形参直接指定默认值的参数
可变长参数：传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个
11、检查代码，如有错误请改正（禁止运行代码）：
a
1 def func(x,y,z): 2 print(x,y,z) 3 4 func(1,2,3)
#输出（1 2 3）
b
1 def func(x,z,y=5): #有赋值的参数，传入的参数必须在右边，否则会报错 2 print(x,y,z) 3 func(1,3,3)
#输出（1 3 3）
c
1 def func(x,y,*z): 2 print(x,y,z) 3 4 func(1,2,3,4,5,6)
#输出 （1 2 （3,4,5,6））
d
1 def func(x,y,*z): 2 print(x,y,z) 3 4 func(1,2,3,4,5,6,6)
#输出（1 2 （3,4,5,6,6））
e
1 def func(x,*z,**y): 2 print(x,y,z) 3 4 func(1,2,3)
#输出（1 {} （2,3））
f
1 def func(x,*y,**z): 2 print(x,y,z) 3 4 func(1,name=2,age=3)
#输出（1 （） {'name':2,'age':3}）
g
1 def func(x,*y,**z): 2 print(x,y,z) 3 4 func(1,2,3,4,name=2,age=3)
#输出（1 （2,3,4） {'name':2,'age':3}）
h
1 def func(x=2,*y,**z): 2 print(x,y,z) 3 4 func(name=2,age=3)
#输出（2 （） {'name':2,'age':3}）
13、书写输出结果（禁止运行代码）：
a
1 def func(*y,**z): 2 print(y,z) 3 4 func(1,2,3,4,5)
#输出（（1,2,3,4,5） {}）
b
1 def func(*y,**z): 2 print(y,z) 3 4 func([1,2,3,4,5])
#输出（（[1,2,3,4,5],） {}）
c
1 def func(*y,**z): 2 print(y,z) 3 4 func(*[1,2,3,4,5])
#输出 （（1,2,3,4,5） {}）
d
1 def func(*y,**z): 2 print(y,z) 3 4 func(*[1,2,3,4,5],name="alex",age=19)
#输出（（1,2,3,4,5） {'name':'alex','age':19}）
e
1 def func(x,*z,**y): 2 print(x,y,z) 3 4 func(1,2,3)
#输出 （1 {} （2,3））
f
1 def func(*y,**z):
2 print(y,z)
3
4 func(*[1,2,3,4,5],**{"name":"alex","age":19})
#输出 （（1,2,3,4,5） {'name':'alex','age':19}）
14、书写执行结果（禁止运行代码）
1 def func1(x=1,*y,**z):
2 print(x,y,z)
3 return y
4 print(x)
5
6 def func2(arg):
7 ret=func1(name=arg)
8 print(ret)
9
10 result = func2("Fuck")
11 print(result)
#输出
1 （） {'name':'Fuck'}
（）
None
15、书写执行结果（禁止运行代码）
1 def func(arg): 2 arg.append(55) 3 4 li=[11,22,33,44] 5 func(li) 6 print(li) 7 li=func(li) 8 print(li)
#输出
[11,22,33,44,55]
None
16、书写执行结果（禁止运行代码）
1 def f1(arg): 2 print(arg+100) 3 4 def f2(arg): 5 ret=f1(arg+1) 6 print(arg) 7 print(ret) 8 9 ret=f2(7) 10 print(ret)
#输出
108
7
None
None
17、简述 Python3 中的 range 函数和 Python2.7 中的 range 函数有什么区别?
返回值的不同： python3中range不会马上生成值，用的时候才生成 python2中range会直接生成一个列表返回
区别示例：
python2.x中的range返回的是一个列表
1 >>> range(1,10) #打印出1-10的数字，python默认从0开始 2 [1, 2, 3, 4, 5, 6, 7, 8, 9]
python3.x中的range返回的是一个迭代值
#错误的方法
1 >>> range(1,10) 2 range(1, 10)
#正确的方法，要想打印出列表，需要加list
1 >>> list(range(1,10)) 2 [1, 2, 3, 4, 5, 6, 7, 8, 9]
18、书写执行结果（禁止运行代码）
a、
1 a="oldboy%" 2 print(a)
#输出
oldboy%
b、
1 b="oldboy%d%%"%(12,) 2 print(b)
#输出
oldboy12%
19、简述对象和类的关系
如果值是某个类型，那么这个值是类的对象
20、书写执行结果（禁止运行代码）
1 def func(a1): 2 return a1 + 100 #func值被系统垃圾回收机制回收。 3 4 func = lambda a1:a1 + 200
def func(a1) 5 return a1 + 200 #下面这个func覆盖掉上面那个a1的值=a1+200=210
6 ret = func(10)
7 print(ret)
#输出
210
21、内置函数 all 和 any 的区别
all : 当传入空可迭代对象时返回True，当可迭代对象中有任意一个不为True，则返回False
any : 当传入空可迭代对象时返回False，当可迭代对象中有任意一个不为False，则返回True
22、简述文件打开模式'r'和'rb'的区别
'r'：只读模式打开，默认utf-8格式
'rb'：以字节的形式打开文件
23、将字符串"老男人"转换成 UTF-8 编码的字节类型
1 name = "老男人"
2 #print(bytes(name, encoding='utf-8'))
3 print(bytes(name, encoding='utf-8').decode('utf-8'))
24、利用内置函数将十进制数字12，分别转换成二进制、八进制、十六进制表示的字符串
1 print(bin(12)) #二进制 2 print(oct(12)) #八进制 3 print(hex(12)) #十六进制
25、简述内置函数 globals()、locals()作用
globals() 获取所有的全局变量
locals() 获取所有局部变量
26、利用内置函数 zip()，实现功能
l1=["alex",22,33,44,55]
l2=["is",22,33,44,55]
l3=["good",22,33,44,55]
l4=["guy",22,33,44,55]
请获取字符串s="alex_is_good_guy"
res = list(zip(l1,l2,l3,l4)) s='_'.join(res[0]
27、判断输出结果是否相同？并可得到什么结论？
1 def f1(arg): 2 print(id(arg)) 3 4 n=1111111 5 print(id(n)) 6 f1(n)
输出的两个值是否相同：相同 对于传参数的时候传值还是传引用？python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。这种方式 相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值－－相当于通过“传引用”来传递对象。如果函数收到的是一 个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象－－相当于通过“传值'来传递对象。
28、书写执行结果（禁止运行代码）
a.
1 NAMELIST=["alex","eric"] 2 3 def func(): 4 NAMELIST=123 5 6 func() 7 print(NAMELIST)
#输出
["alex","eric"]
b.
1 NAMELIST=["alex","eric"] 2 3 def func(): 4 global NAMELIST 5 NAMELIST=123 6 7 func() 8 print(NAMELIST)
#输出
123
c.
1 NAMELIST=["alex","eric"]
2
3 def func():
4 NAMELIST.append("seven")
5
6 func()
7 print(NAMELIST)
#输出
["alex","eric","seven"]
d
1 NAMELIST = ["alex", "eric"] 2 3 def func(): 4 NAMELIST = 123 5 global NAMELIST 6 7 func() 8 print(NAMELIST)
输出结果为：报错 SyntaxError: name 'NAMELIST' is assigned to before global declaration
29、书写执行结果（禁止运行代码）
a.
1 name = "root" 2 def func(): 3 name = "seven" 4 def outer(): 5 name = "eric" 6 def inner(): 7 global name 8 name = "蒙逼了吧..." 9 print(name) 10 print(name) 11 12 ret = func() 13 print(ret) 14 print(name)
输出结果为：
seven
None
root
b.
1 name = "root" 2 def func(): 3 name = "seven" 4 def outer(): 5 name = "eric" 6 def inner(): 7 global name 8 name = "蒙逼了吧..." 9 print(name) 10 o = outer() 11 print(o) 12 print(name) 13 14 ret = func() 15 print(ret) 16 print(name)
输出结果为：
eric
None
seven
None
root
c.
1 name = "root" 2 def func(): 3 name = "seven" 4 def outer(): 5 name = "eric" 6 def inner(): 7 global name 8 name = "蒙逼了吧..." 9 print(name) 10 inner() 11 o = outer() 12 print(o) 13 print(name) 14 15 ret = func() 16 print(ret) 17 print(name)
输出结果为：
eric
None
seven
None
蒙逼了吧...
d.
1 name = "root" 2 def func(): 3 name = "seven" 4 def outer(): 5 name = "eric" 6 def inner(): 7 nonlocal name 8 name = "蒙逼了吧..." 9 print(name) 10 inner() 11 o = outer() 12 print(o) 13 print(name) 14 15 ret = func() 16 print(ret) 17 print(name)
输出结果为：
eric
None
seven
None
root
30、书写执行结果并解释每一步操作
a.
1 name = "苍老师" 2 3 def outer(func): 4 name = 'alex' 5 func() 6 7 def show(): 8 print(name) 9 outer(show)
执行结果：
苍老师
b.
1 name = "苍老师" 2 3 def outer(): 4 name = "波多" 5 def inner(): 6 print(name) 7 return inner() 8 9 ret = outer() 10 print(ret)
输出结果为：
波多
None
c.
1 name = "苍老师" 2 3 def outer(): 4 name = "波多" 5 def inner(): 6 print(name) 7 return inner 8 9 ret = outer() 10 ret() 11 print(ret) 12 result = ret() 13 print(result)
输出结果为：
波多
<function outer.<locals>.inner at 0x01225660> #inner内存地址
波多
None
d.
1 name = "苍老师" 2 3 def outer(): 4 name = "波多" 5 def inner(): 6 print(name) 7 return inner 8 9 ret = outer() 10 print(ret) 11 result = ret() 12 print(result)
输出结果为：
<function outer.<locals>.inner at 0x01225660> #inner内存地址
波多
None
e.
1 name = "苍老师" 2 3 def outer(func): 4 def inner(): 5 name = "李杰" 6 func() 7 return inner 8 9 def show(): 10 print(name) 11 12 outer(show)()
执行结果：
苍老师
31、书写执行结果并解释每一步操作
a.
1 def outer(func,z,y): 2 func(z) 3 4 def show(x): 5 return x * x 6 7 ret = outer(show,9,23) 8 9 print(ret)
输出结果为：
None
b.
1 def outer(func, z, y): 2 return func(z) 3 def show(x): 4 return x * x 5 6 ret = outer(show,9,23) 7 print(ret)
输出结果为：
81
c.
1 def outer(func,z,y): 2 func(z,y) 3 4 f1 = lambda x,y:x+y 5 ret = outer(f1,11,23) 6 print(ret)
输出结果为：
None
d.
1 def outer(func, z, y): 2 return func(z, y) 3 4 f1 = lambda x,y:x + y 5 ret = outer(f1, 11, 23) 6 print(ret)
输出结果为：
34
32、写输出结果
a.
1 def f5(arg):
2 arg.append('偷到 500 万')
3
4 def f4(arg):
5 arg.append('开第四个门')
6 f5(arg)
7 arg.append('关第四个门')
8
9 def f3(arg):
10 arg.append('开第三个门')
11 f4(arg)
12 arg.append('关第三个门')
13
14 def f2(arg):
15 arg.append('开第二个门')
16 f3(arg)
17 arg.append('关第二个门')
18
19 def f1(arg):
20 arg.append('开一个门')
21 f2(arg)
22 arg.append('关一个门')
23
24 user_list = []
25 result = f1(user_list)
26 print(user_list)
27 print(result)
输出结果为：
['开一个门', '开第二个门', '开第三个门', '开第四个门', '偷到 500 万', '关第四个门', '关第三个门', '关第二个门', '关一个门']
None
b.
1 def f5(arg): 2 arg = arg + 5 3 4 def f4(arg): 5 arg = arg + 4 6 f5(arg) 7 arg = arg + 4 8 9 def f3(arg): 10 arg = arg + 3 11 f4(arg) 12 arg = arg + 3 13 14 def f2(arg): 15 arg = arg + 2 16 f3(arg) 17 arg = arg + 2 18 19 def f1(arg): 20 arg = arg + 1 21 f2(arg) 22 arg = arg + 1 23 24 num = 1 25 result = f1(num) 26 print(num) 27 print(result)
输出结果为：
1
None
c.
1 def f5(arg): 2 arg = arg + 5 3 return arg 4 5 def f4(arg): 6 arg = arg + 4 7 f5(arg) 8 arg = arg + 4 9 return arg 10 11 def f3(arg): 12 arg = arg + 3 13 f4(arg) 14 arg = arg + 3 15 return arg 16 17 def f2(arg): 18 arg = arg + 2 19 f3(arg) 20 arg = arg + 2 21 return arg 22 23 def f1(arg): 24 arg = arg + 1 25 f2(arg) 26 arg = arg + 1 27 return arg 28 29 num = 1 30 result = f1(num) 31 print(num) 32 print(result)
输出结果为：
1
3
d、利用递归实现32 题中c题的功能
1 def fnuc(x,y=0): 2 y += 1 3 if y == 5: 4 return x + y 5 x += y 6 func(x,y) 7 x += y 8 return x 9 10 num = 1 11 result = fnuc(num) 12 print(num) 13 print(result)
33、利用递归实现1*2*3*4*5*6*7
def fib(n):
if n==1:
return 1
return n*fib(n-1)
res = fib(7)
print(res)
from functools import reduce print(reduce(lambda x,y:x*y,[x for x in range(1,8)]))
34、写程序
a.利用filter、自定义函数获取 l1 中元素大于 33 的所有元素l1=[11,22,33,44,55]
l1=[11,22,33,44,55]
def fib(n):
l = []
if n>33:
l.append(n)
return l
res = list(filter(fib,l1))
print(res)
内置函数filter和lambda
res = list(filter(lambda n:n>33,l1))
print(res)
b.利用filter、lambda 表达式获取 l1 中元素小于 33 的所有元素l1=[11,22,33,44,55]
l1=[11,22,33,44,55] res = list(filter(lambda n:n<33,l1)) print(res)
c.利用map、自定义函数将所有是奇数的元素加 100
l1=[11,22,33,44,55]
def fib(n):
if n%2!=0:
n+=100
return n
res = list(map(fib,l1))
print(res)
d.利用map、lambda 表达式将所有是偶数的元素加 100
l1=[11,22,33,44,55]
35、写程序
a.文件操作时 with 的作用？
在操作文件结束后自动关闭
b.写程序：利用 with 实现同时打开两个文件（一读，一写，并将读取的内容写入到写入模式的文件中）
with open('a.txt','r',encoding='utf-8') as file_a,open('b.txt','w',encoding='utf-8') as file_b:
file_b.write(file_a.read())
36、写函数：
如有以下两个列表
l1=[...]
l2=[]
第一个列表中的数字无序不重复排列，第二个列表为空列表
需求：
取出第一个列表的最小值放到第二个列表的首个位置，
取出第一个列表的最小值（仅大于上一次的最小值）放到第二个列表的首个位置，
取出第一个列表的最小值（仅大于上一次的最小值）放到第二个列表的首个位置，
...
依此类推，从而获取一个有序的列表 l2，并将其返回给函数调用者。
deffunc(l1,l2):
pass
l1 = [50,70,30,80,75]
l2 = []
def deffunc(n1,n2):
while True:
if l1:
res=min(n1)
n1.remove(res)
n2.insert(0,res)
else:break
return n2
res = deffunc(l1,l2)
print(res)
37、猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，还是不过瘾又多吃了一个。以后每天都吃前一天剩下的一半再加一个。到第 10 天刚好剩一个。问猴子第一天摘了多少个桃子？
p = 1
print('第10天吃之前就剩1个桃子')
for i in range(9, 0, -1):
p = (p+1) * 2
print('第%s天吃之前还有%s个桃子' % (i, p))
print('第1天共摘了%s个桃子' % p)
输出：
第10天吃之前就剩1个桃子
第9天吃之前还有4个桃子
第8天吃之前还有10个桃子
第7天吃之前还有22个桃子
第6天吃之前还有46个桃子
第5天吃之前还有94个桃子
第4天吃之前还有190个桃子
第3天吃之前还有382个桃子
第2天吃之前还有766个桃子
第1天吃之前还有1534个桃子
第1天共摘了1534个桃子
s = 1
func = lambda x: (x + 1) * 2
for i in range(9):
s = func(s)
print(s)
输出：
1534
