对函数，内置函数的用法，递归，程序运行顺序的考试
1、列举布尔值为 False 的值
0 False '' [] () {} None
经常使用的场景是 if object 如果object有值就执行，而不用关心object具体是什么。
2、写函数:
根据范围获取其中能被 3 和 7 整除的所有数的和，并返回调用者:
符合条件的数字个数以及符合条件的数字的总和 如: def func(start,end):
方法一：for循环
def func(start,end):
sum_l = 0
count_l = 0
for i in range(start,end):
if (i % 3 == 0) and (i % 7 == 0):
sum_l += i
count_l += 1
return count_l,sum_l print(func(3,22)) #输出(1, 21)
方法二：迭代
def func(start,end,count_l = 0,sum_l = 0):
if start == end:
return count_l,sum_l
if (start % 3 == 0) and (start % 7 == 0):
sum_l += start
count_l += 1
ret = func(start +1,end,count_l,sum_l)
return ret print(func(3,22)) #输出(1, 21)
3、函数的默认返回值是什么?
None
4、简述 break / continue / return 的区别
break:结束当前循环
continue：结束本次循环进入下一次循环
return:结束函数，并返回结果，默认为None
5、函数传递参数时，是引用还是复制值?并证明
引用
def test(x):
print('函数内地址：',id(x)) y = 1
test(y)
print('函数外地址：',id(y))
'''输出：
函数内地址： 1713045968
函数外地址： 1713045968
'''
6、简述三元运算书写格式以及应用场景
变量 = 值一 if 条件一 else 值二
将简单的条件判断精简写
7、简述 lambda 表达式书写格式以及应用场景
函数名 = lambda 形参: 功能 不写函数名也可以
将简单的函数书写成匿名函数，减少代码
题外话：Python语言里面“一切皆对象”
1 是 数字类的对象
'你好' 是字符串类的对象
func() 是函数类的对象
存储方法：
1,x = 1 x指向值为1的内存地址
2,def f()
print('OK')
f函数名指向内容为print('OK')的内存地址
3,匿名函数lambda 在内存中执行完一次就被自动回收，所以比较省资源
8、使用 set 集合获取两个列表 l1 = [11, 22, 33], l2 = [22, 33, 44] 中相同的元素集合
l1 = [11, 22, 33]
l2 = [22, 33, 44]
s1 = set(l1)
s2 = set(l2)
print(s1.intersection(s2))
print(s1 & s2)
9、定义函数统计一个字符串中大写字母、小写字母、数字的个数，并以字典为结果返回给调用着
提示:可以用 id 进行判断
def show(xx):
yy = {"数字":0,"大写":0,"小写":0}
for i in xx:
i = str(i)
if i.isdigit():
yy["数字"] += 1
elif i.isupper():
yy["大写"] += 1
elif i.islower():
yy["小写"] += 1
return yy
xx = input(">>>>")
ret = show(xx)
print(ret)
10、简述函数的 位置参数、关键字参数、默认参数、可变长参数的特点以及注意事项
形参：普通参数，默认参数，动态参数
实参：位置参数，关键字参数
注：位置参数必须是在关键字参数前，形参也是普通参数最左，默认参数次之，动态参数最右
位置参数：按形参的位置传入 叫位置参数 就是普通参数
关键字参数：传入实参时指定形参的值
默认参数：形参直接指定默认值的参数
可变长参数：*args **kwargs ,一个星只能接收没有位置参数的的实参或参数的列表，元组，俩个星可以接收关键字参数，和字典格式
11、检查代码，如有错误请改正(禁止运行代码):
a.
def func(x,y,z):
print(x,y,z)
func(1,2,3)
输出结果为:1 2 3
b.
def func(x,z,y=5):
print(x,y,z)
func(1,3,3)
输出结果为:1 3 3
c.
def func(x,y,*z):
print(x,y,z)
func(1,2,3,4,5,6)
输出结果为:1 2 (3,4,5,6)
e.
def func(x,*z,**y):
print(x,y,z)
func(1,2,3)
输出结果为:1 {} (2,3)
f.
def func(x,*y,**z):
print(x,y,z)
func(1,name=2,age=3)
输出结果为:1 () {'age': 3, 'name': 2}
g.
def func(x,*y,**z):
print(x,y,z)
func(1,2,3,4, name=2,age=3)
输出结果为:1 (2,3,4) {"name":2,"age":3}
h.
def func(x=2,*y,**z):
print(x,y,z)
func(name=2,age=3)
输出结果为:2 () {'age': 3, 'name': 2}
13、书写输出结果(禁止运行代码):
a.
def func(*y,**z):
print(y,z)
func(1,2,3,4,5)
输出结果为:(1,2,3,4,5) {}
b.
def func(*y,**z):
print(y,z)
func([1,2,3,4,5])
输出结果为:([1,2,3,4,5]) {}
c.
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5])
输出结果为:(1,2,3,4,5) {}
d.
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5],name="alex",age=19)
输出结果为:(1,2,3,4,5) {"name":"alex","age":19}
e.
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5], { "name":"alex","age":19})
输出结果为:(1,2,3,4,5,{ "name":"alex","age":19}) {}
注意：给**传参数要么像上一题使用键值对，要么使用**，但是本题不符合这两个条件，只能传给y
f.
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5], **{ "name":"alex","age":19})
输出结果为:(1,2,3,4,5) { "name":"alex","age":19}
14、书写执行结果(禁止运行代码)
def func1(x=1,*y,**z):
print(x,y,z)
return y
print(x)
def func2(arg):
ret = func1(name=arg)
print(ret)
result = func2("Fuck")
print(result)
输出结果为:
1 () {'name': 'Fuck'}
()
None
15、书写执行结果(禁止运行代码)
def func(arg):
arg.append(55)
li = [11, 22, 33, 44]
func(li)
print(li)
li = func(li)
print(li)
输出结果为:
[11, 22, 33, 44, 55]
None
16、书写执行结果(禁止运行代码)
def f1(arg):
print(arg+100)
def f2(arg):
ret = f1(arg+1)
print(arg)
print(ret)
ret = f2(7)
print(ret)
输出结果为:
108
7
None
None
17、简述 Python3 中的 range 函数和 Python2.7 中的 range 函数有什么区别
3.x range 不会生成值 只有用的时候才会生成（就是一个生成器）
2.7 range 会直接生成一个列表，值已经生成
18、书写执行结果(禁止运行代码)
a = "oldboy %"
print(a)
输出结果为:oldboy %
b = "oldboy %d %%" % (12,)
print(b)
输出结果为:oldboy 12%
19、简述对象和类的关系
如果值是某类型，那这个值就是这个类的对象
20、书写执行结果(禁止运行代码)
def func(a1):
return a1 + 100
func = lambda a1: a1 + 200
ret = func(10)
print(ret)
输出结果为:210
21、内置函数 all 和 any 的区别
all 是如果是空的，返回True 如果非空，全真为真否则为假
any 是有一个为真就为真
22、简述文件打开模式 'r' 和 'rb' 的区别
r 是只读模式打开，默认以utf-8格式
rb 是以二进制格式打开
23、将字符串 "老男人" 转换成 UTF-8 编码的字节类型
name = "老男孩"
print(bytes(name,encoding="utf-8"))
print(name.encode(encoding="utf-8"))
'''输出
b'\xe8\x80\x81\xe7\x94\xb7\xe5\xad\xa9'
b'\xe8\x80\x81\xe7\x94\xb7\xe5\xad\xa9'
'''
24、利用内置函数将十进制数字 12，分别转换成 二进制、八进制、十六进制 表示的字符串
print(bin(12))
print(oct(12))
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"
l1 = ["alex",22,33,44,55]
l2 = ["is",22,33,44,55]
l3 = ["good",22,33,44,55]
l4 = ["guy",22,33,44,55]
print("_".join(list(zip(l1,l2,l3,l4))[0]))
print(list(zip(l1,l2,l3,l4)))
'''输出：
[('alex', 'is', 'good', 'guy'), (22, 22, 22, 22), (33, 33, 33, 33), (44, 44, 44, 44), (55, 55, 55, 55)]
'''
27、判断输出结果是否相同?并可得到什么结论?
def f1(arg):
print(id(arg))
n = 1111111
print(id(n))
f1(n)
输出的两个值是否相同: 相同
执行函数是引用变量值，而不是复制
28、书写执行结果(禁止运行代码)
a.
NAMELIST = ["alex", "eric"]
def func():
NAMELIST = 123
func()
print(NAMELIST)
输出结果为:["alex", "eric"]
b.
NAMELIST = ["alex", "eric"]
def func():
global NAMELIST
NAMELIST = 123
func()
print(NAMELIST)
输出结果为:123
c.
NAMELIST = ["alex", "eric"]
def func():
NAMELIST.append("seven")
func()
print(NAMELIST)
输出结果为:["alex", "eric","seven"]
d.
NAMELIST = ["alex", "eric"]
def func():
NAMELIST = 123
global NAMELIST
func()
print(NAMELIST)
输出结果为:警告，可以执行
SyntaxWarning: name 'NAMELIST' is assigned to before global declaration
global NAMELIST
123
29、书写执行结果(禁止运行代码)
a.
name = "root"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
global name
name = "蒙逼了吧..."
print(name)
print(name)
ret = func()
print(ret)
print(name)
输出结果为:
seven
None
root
b.
name = "root"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
global name
name = "蒙逼了吧..."
print(name)
o = outer()
print(o)
print(name)
ret = func()
print(ret)
print(name)
输出结果为:
eric
None
seven
None
root
c.
name = "root"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
global name
name = " ..."
print(name)
inner()
o = outer()
print(o)
print(name)
ret = func()
print(ret)
print(name)
输出结果为:
eric
None
seven
None
...
d.
name = "root"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
nonlocal name
name = "蒙逼了吧..."
print(name)
inner()
o = outer()
print(o)
print(name)
ret = func()
print(ret)
print(name)
输出结果为:
蒙逼了吧...
None
seven
None
root
30、书写执行结果并解释每一步操作
a.
name = "苍老师"
def outer(func):
name = 'alex'
func() #结果，就是执行的show
def show():
print(name)
outer(show)
结果：苍老师
b.
name = "苍老师"
def outer():
name = "波多"
def inner():
print(name)
return inner()
ret = outer()
print(ret)
输出结果为:
波多
None
c.
name = "苍老师"
def outer():
name = "波多"
def inner():
print(name)
return inner
ret = outer()
ret() #输出"波多"
print(ret) #输出inner内存地址
result = ret()#输出"波多"
print(result) #输出 None
输出结果为:
波多
<function outer.<locals>.inner at 0x00000000025E26A8>
波多
None
d.
name = "苍老师"
def outer():
name = "波多"
def inner():
print(name)
return inner #返回内存地址
ret = outer()
print(ret) #打印inner内存地址
result = ret() #执行inner函数，打印波多
print(result) #inner无返回值 打印的是None
输出结果为:
<function outer.<locals>.inner at 0x00000000026026A8>
波多
None
e.
name = "苍老师"
def outer(func):
def inner():
name = "李杰"
func()
return inner
def show():
print(name)#打印全局的
outer(show)()
输出结果为:苍老师
31、书写执行结果并解释每一步操作
a.
def outer(func,z,y):
func(z) #不管这里运行什么，outer函数本身没有return，只能默认返回None
def show(x):
return x * x
ret = outer(show,9,23)
print(ret)
输出结果为:None
b.
def outer(func,z,y):
return func(z)
def show(x):
return x * x
ret = outer(show,9,23)
print(ret)
输出结果为:81
c.
def outer(func,z,y):
func(z,y)
f1 = lambda x,y: x + y
ret = outer(f1,11,23)
print(ret)
输出结果为:None
d.
def outer(func,z,y):
return func(z,y)
f1 = lambda x,y: x + y
ret = outer(f1,11,23)
print(ret)
输出结果为:34
32、写输出结果
a.
def f5(arg):
arg.append('偷到 500 万')
def f4(arg):
arg.append('开第四个门')
f5(arg)
arg.append('关第四个门')
def f3(arg):
arg.append('开第三个门')
f4(arg)
arg.append('关第三个门')
def f2(arg):
arg.append('开第二个门')
f3(arg)
arg.append('关第二个门')
def f1(arg):
arg.append('开一个门')
f2(arg)
arg.append('关一个门')
user_list = []
result = f1(user_list)
print(user_list)
print(result)
输出结果为:
['开一个门', '开第二个门', '开第三个门', '开第四个门', '偷到 500 万', '关第四个门', '关第三个门', '关第二个门', '关一个门']
None
b.
def f5(arg):
arg = arg + 5
def f4(arg):
arg = arg + 4
f5(arg)
arg = arg + 4
def f3(arg):
arg = arg + 3
f4(arg)
arg = arg + 3
def f2(arg):
arg = arg + 2
f3(arg)
arg = arg + 2
def f1(arg):
arg = arg + 1
f2(arg)
arg = arg + 1
num = 1
result = f1(num)
print(num)
print(result)
输出结果为:1 None
c.
def f5(arg):
arg = arg + 5
return arg
def f4(arg):
arg = arg + 4
f5(arg)
arg = arg + 4
return arg
def f3(arg):
arg = arg + 3
f4(arg)
arg = arg + 3
return arg
def f2(arg):
arg = arg + 2
f3(arg)
arg = arg + 2
return arg
def f1(arg):
arg = arg + 1
f2(arg)
arg = arg + 1
return arg
num = 1
result = f1(num)
print(num)
print(result)
输出结果为:
1
3
33、利用递归实现 32 题中 c 题的功能
下面的程序不是实现32题中的C题的功能，因为C题也没体现出递归的想法
def func(x, y=0):
y += 1
if y == 5:
return x + y
x += func(x, y)
return x num = 1
result = func(num)print(result)
一共迭代了6次
传入值
x=1——x=1——x=1——x=1——x=1——x=1
y=0——y=1——y=2——y=3——y=4——y=5
返回值
x=最终——x=10——x=9——x=8——x=7——x=6
34、利用递归实现 1*2*3*4*5*6*7=5040
第一种：思路不清
def func(x, y=0):
x -= 1
y += 1
if x == 1:
return x * y
y *= func(x, y)
return y num = 8
result = func(num)
print(result)
第二种：思路清晰
def func(x):
if x == 1:
return 1
return x*func(x-1) result = func(7)
print(result)
reduce+lambda写法
from functools import reduce
print(reduce(lambda x,y:x*y,[x for x in range(1,8)]))
35、写程序
a. 利用 filter、自定义函数 获取 l1 中元素大于 33 的所有元素 l1 = [11, 22, 33, 44, 55]
l1 = [11, 22, 33, 44, 55]
def dy(x):
if x>33:
return x
print(list(filter(dy,l1)))
b.利用 filter、lambda 表达式 获取 l1 中元素小于 33 的所有元素 l1 = [11, 22, 33, 44, 55]
l1 = [11, 22, 33, 44, 55]
print(list(filter(lambda x:x<33,l1)))
c.利用 map、自定义函数 将所有是奇数的元素加 100 l1 = [11, 22, 33, 44, 55]
l1 = [11, 22, 33, 44, 55]
def dy(x):
if x%2 == 1:
return x+100
else:
return x
print(list(map(dy,l1)))
d.利用 map、lambda 表达式 将所有是偶数的元素加 100 l1 = [11, 22, 33, 44, 55]
l1 = [11, 22, 33, 44, 55]
print(list(map(lambda x:x+100 if x%2 == 0 else x,l1)))
36、写程序
a. 文件操作时 with 的作用?
with 打开文件执行完毕后自动关闭
b. 写程序:利用 with 实现同时打开两个文件(一读，一写，并将读取的内容写入到写入模式的文件中)
with open("a","r",encoding='utf-8') as x,open("b","w") as y:
y.write(x.read())
37、写函数: 如有以下两个列表
l1 = [...]
l2 = []
第一个列表中的数字无序不重复排列，第二个列表为空列表
需求:
取出第一个列表的最小值 放到第二个列表的首个位置，
取出第一个列表的最小值(仅大于上一次的最小值) 放到第二个列表的首个位置，
取出第一个列表的最小值(仅大于上一次的最小值) 放到第二个列表的首个位置， ...
依此类推，从而获取一个有序的列表 l2，并将其返回给函数调用者。
l1 = [1,5,4,6,8,3,2,9,0]
l2 = []
def func(la,lb):
if len(la) ==0:
return lb
a = min(la)
la.remove(a)
lb.insert(0,a)
ret = func(la,lb)
return ret
func(l1,l2)
print(l2)
#输出：[9, 8, 6, 5, 4, 3, 2, 1, 0]
第二种使用pop方法
l1 = [3,2,1,7,6,8]
l2 = [] def sort1():
while True:
if l1:
for index,i in enumerate(l1):
if i == max(l1):
l2.append(l1.pop(index))
else:
return
sort1()
print(l2)
#输出：[8, 7, 6, 3, 2, 1]
38、猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，
还是不过瘾又多吃 了一个。以后每天都吃前一天剩下的一半再加一个。到第 10 天刚好剩一个。
问猴子第一天摘了多少个桃子?1534
def func(x,y):
y -= 1
if y == 1:
return x
return func((x+1)*2,y) ret = func(1,11)
print(ret)
输出：1534