1,列举布尔值为False的值
0 False ‘’ [] {} None
2, 写函数：
根据范围获取其中3和7整除的所有数的和，并返回调用者：
符合条件的数字个数以及符合条件的数字的总和 如：def func(start ,end):
3,函数的默认返回值是什么？
None
4,简述break\continue\return的区别
Break：结束当前循环
Continue:结束本次循环进入下一次循环
Return：结束函数，并返回结果，默认为None
5,函数传递参数时，是引用还是复制值，并证明
引用
Name = ‘guanyu’
Def show():
Print(id(name))
print(id(name))
show()
6,简述三元运算书写格式以及应用场景
变量=值-if条件-else值二
将简单的条件判断精简写
7，简述lambda表达式书写格式以及应用场景
函数名 =lambda 形式：功能 不写函数名也可以
将简单的函数书写成匿名函数，减少代码
8，使用set 集合获取两个列表l1=[11,22,33],l2=[22,33,44]中相同的元素集合
l1=[11,22,33]
l2=[22,33,44]
set(l1)&set(l2)
9，定义函数统计一个字符串中大写字母，小写字母，数字的个数，并以字典为结果返回给调用者
10，简述函数的 位置参数，关键字参数，默认参数，可变长参数的特点以及注意事项
位置参数：按形参的位置传入 叫位置参数就是普通参数
关键字参数：传入实参时制定形参的值
默认参数：形参直接指定默认值的参数
可变长参数：*arge **kwargs,一个只能接收没有位置参数的实参和参入的列表，元组，俩
可以接受关键字参数，和字典格式
11，检查代码，如有错误请改正
# 1.
def func(x,y,z):
print(x,y,z)
func(1,2,3)
#2
def func(x,y,z=5):
print(x,y,z)
func(1,3,3)
#3
def func(x,y,*z):
print(x,y,z)
func(1,2,3,4,5,6)
#4
def func(x,y,*z):
print(x,y,z)
func(1,2,3,4,5,6,6)
#5
def func(x,*z,**y):
print(x,y,z)
func(1,2,3)
# 你定义的函数 func 使用了混合参数类型：位置参数 x，可变位置参数 *z，和可变关键字参数 **y。在调用 func(1, 2, 3) 时，参数的分配如下：
# x 接收第一个位置参数 1。
# *z 接收剩余的所有位置参数，即 2 和 3，所以 z 是一个包含 2 和 3 的元组。
# **y 接收关键字参数，但由于调用时没有提供任何关键字参数，所以 y 是一个空字典。
# 因此，调用 func(1, 2, 3) 后，函数内部的 x, y, 和 z 的值分别是：
# x 是 1
# y 是 {}（空字典）
# z 是 (2, 3)（包含 2 和 3 的元组）
# 函数 func 的输出将是：
# 1 {} (2, 3)
#6
def func(x,*y,**z):
print(x,y,z)
func(1,name=2,age=3) #键值对会传给字典
#7
def func(x,*y,**z):
print(x,y,z)
func(1,2,3,4,name=2,age=3)
#8
def func(x=2,*y,**z):
print(x,y,z)
func(name=2,age=3)
#9
def func(*y,**z):
print(y,z)
func(1,2,3,4,5)
#10
def func(*y,**z):
print(y,z)
func([1,2,3,4,5])
#11
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5])
#12
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5],name='alexa',age=29)
#13
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5],{'name':'alexa','age':29}) #属于元组的内容
#14
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5],**{'name':'alexa','age':29}) #属于元组的内容
# 15
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)
# 输出结果为："name"："fuck") 0 Non
# 以下是修正后的代码：
def func1(x=1, *y, **z):
print(x, y, z)
return y
def func2(arg):
ret = func1(name=arg)
print(ret)
return ret
# 调用 func2 并打印结果
result = func2("Fuck")
print(result)
# 15、书写执行结果(禁止运行代码)
def func(arg):
arg.append(55)
li = [11, 22, 33, 44]
func(li)
print(li)
func(li)
print(li)
# 16，书写执行结果(禁止运行代码)
def f1(arg):
print(arg + 100)
def f2(arg):
ret = f1(arg + 1)
print(arg)
print(ret)
ret = f2(7)
print(ret)
17、简述Python3中的range函数和Python2..7中的range函数有什
么区别
3.x range不会生成值只有用的时候才会生成
2.7 range会直接生成一个列表,值已经生成
# 18、书写执行结果(禁止运行代码)
a = "goodboy %"
print(a)
# 输出结果为: goodboy %
b = "goodboy%d%%" % (12,)
print(b)
# 输出结果为: goodboy12%
19、简述对象和类的关系
如果值是某类型,那这个值就是这个类的对象
20、书写执行结果(禁止运行代码)
def func(al):
return al + 100
func = lambda al: al + 200
ret = func(10)
print(ret)
# 输出结果为:210
21、内置函数all和any的区别
all是如果是空的,返回True如果非空,全真为真否侧为假
any是有一个为真就为真
22、简述文件打开模式’r’和'rb'的区别
r是只读模式打开,默认以uf-8格式
b是以二进制格式打开
23、将字符串"夏侯惇”转换成UTF-8编码的字节类型
S = '夏侯惇'
print(type(S)) # 这里应该是大写的 S
a = bytes(S, 'utf-8')
encoded_s = S.encode('utf-8') # 这一行代码可以保留，但需要赋值给一个变量
print(a)
print(encoded_s)
24、利用内置函数将十进制数字12,分别转换成二进制、八进制、十六进制表示的字符串
# 十进制数字
decimal_number = 12
# 转换为二进制
binary_string = bin(decimal_number)
# 转换为八进制
octal_string = oct(decimal_number)
# 转换为十六进制
hexadecimal_string = hex(decimal_number)
# 打印结果
print(f"二进制: {binary_string}")
print(f"八进制: {octal_string}")
print(f"十六进制: {hexadecimal_string}")
25、简述内置函数globals(0、locals0作用
Globals()获取所有的全局变量
Locals()获取所有局部变量
26、利用内置函数zip(),实现功能
请获取字符串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]
# 提取字符串并拼接,方法1
s = "_".join([l1[0], l2[0], l3[0], l4[0]])
print(s)
# 方法2
# 使用 zip 函数将列表组合在一起
zipped_list = list(zip(l1, l2, l3, l4))
# 提取第一个元组并拼接成字符串
s = "_".join(zipped_list[0])
print(s)
27、判断输出结果是否相同?并可得到什么结论?
输出的两个值是否相同:相同
执行函数是调用变量值不是复制
def fl(arg):
print(id(arg))
n = 1111111
print(id(n))
f1(n) # 这里假设 f1 函数已经定义
# 假设 f1 函数定义如下
def f1(arg):
print(id(arg))
# 调用 fl 函数
fl(12345)
运行这段代码，你会得到以下输出（具体地址会根据运行环境有所不同）：
4325729616 # id(arg) 的输出
4325730032 # id(n) 的输出
4325730032 # id(arg) 在 f1 函数中的输出
解释：
fl 函数接受一个参数 arg，并打印其内存地址 id(arg)。
在 fl 函数内部，定义了一个变量 n，并打印其内存地址 id(n)。
调用 f1(n)，假设 f1 函数已经定义，并打印传递给它的参数的内存地址 id(arg)。
请确保在调用 fl 函数之前，f1 函数已经被正确定义。
解释：
fl 函数接受一个参数 arg，并打印其内存地址 id(arg)。
在 fl 函数内部，定义了一个变量 n，并打印其内存地址 id(n)。
调用 f1(n)，假设 f1 函数已经定义，并打印传递给它的参数的内存地址 id(arg)。
请确保在调用 fl 函数之前，f1 函数已经被正确定义。
28、书写执行结果(禁止运行代码)
a.
# 定义一个全局变量 NAMELIST
NAMELIST = ["alex", "eric"]
def func():
# 在函数内部定义一个同名局部变量
NAMELIST = 123
print("Inside func:", NAMELIST)
# 调用函数
func()
# 打印全局变量 NAMELIST
print("Outside func:", NAMELIST)
输出结果为:
Inside func: 123
Outside func: ['alex', 'eric']
b.
# 定义一个全局变量 NAMELIST
NAMELIST = ["alex", "eric"]
def func():
# 使用 global 关键字声明 NAMELIST 为全局变量
global NAMELIST
# 修改全局变量 NAMELIST 的值
NAMELIST = 123
# 调用函数
func()
# 打印全局变量 NAMELIST
print(NAMELIST)
输出结果为:123
C.
# 定义一个全局变量 NAMELIST
NAMELIST = ["alex", "eric"]
def func():
# 在函数内部修改全局变量 NAMELIST，添加元素 "seven"
NAMELIST.append("seven")
# 调用函数
func()
# 打印全局变量 NAMELISTprint(NAMELIST)
输出结果为:['alex', 'eric', 'seven']
29、书写执行结果
#a
# 定义一个全局变量 name
name = "全局作用域的name"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
global name
name = "我是诸葛亮..."
inner()
print("outer 中的 name:", name)
outer()
print("func 中的 name:", name)
# 调用函数
func()
print("全局作用域的 name:", name)
运行这段代码，你会得到以下输出：
outer 中的 name: eric
func 中的 name: seven
全局作用域的 name: 我是诸葛亮...
#b
# 定义一个全局变量 name
name = "root"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
global name
name = "我是赵云..."
inner()
print("outer 中的 name:", name)
outer()
print("func 中的 name:", name)
ret = func()print("返回值 ret:", ret)print("全局作用域的 name:", name)
运行这段代码，你会得到以下输出：
outer 中的 name: eric
func 中的 name: seven
返回值 ret: None
全局作用域的 name: 我是赵云...
#c
# 定义一个全局变量 name
name = "root"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
global name
name = "..."
print("outer 中的 name (调用 inner 之前):", name)
inner()
print("outer 中的 name (调用 inner 之后):", name)
outer()
print("func 中的 name:", name)
ret = func()print("返回值 ret:", ret)print("全局作用域的 name (调用 func 之后):", name)
name = "root"print("全局作用域的 name (重新赋值之后):", name)
运行这段代码，你会得到以下输出：
outer 中的 name (调用 inner 之前): eric
outer 中的 name (调用 inner 之后): eric
func 中的 name: seven
返回值 ret: None
全局作用域的 name (调用 func 之后): ...
全局作用域的 name (重新赋值之后): root
#d
# 定义一个全局变量 name
name = "全局作用域的name"
def func():
name = "seven"
def outer():
name = "eric"
def inner():
nonlocal name
name = "我数张飞..."
print("inner 中的 name:", name)
inner()
print("outer 中的 name:", name)
outer()
print("func 中的 name:", name)
ret = func()print("返回值 ret:", ret)print("全局作用域的 name:", name)
运行这段代码，你会得到以下输出：
inner 中的 name: 我数张飞...
outer 中的 name: 我数张飞...
func 中的 name: seven
返回值 ret: None
全局作用域的 name: 全局作用域的name
30、书写执行结果并解释每一步操作
#a.
# 定义一个全局变量 name
name = "五虎上将"
# 定义一个装饰器函数 outer
def outer(func):
name = 'alex'
def wrapper():
print("执行前")
func()
print("执行后")
return wrapper
# 定义一个被装饰的函数 show
@outer
def show():
print(name)
# 调用被装饰的函数 show
show()
#b
name = "司马懿"
def outer():
name = "很多"
def inner():
print(name)
return inner
ret = outer()
ret()print(ret)
输出结果为：
很多
<function outer.<locals>.inner at 0x7f8b8c0b4e50>
#c
name = "孙权"
def outer():
name = "少年"
def inner():
print(name)
return inner
ret = outer()
ret()
print(ret)
result = ret()
print(result)
输出结果：
少年
<function outer.<locals>.inner at 0x000000000240E0D0>
少年
None
#d
name = "华雄"
def outer():
name = "被斩"
def inner():
print(name)
return inner # 返回内存地址
ret = outer()
print(ret)
result = ret() # 执行inner函数, 打印波多
print(result) # inner无返回值打印的是None
输出结果为：
<function outer.<locals>.inner at 0x00000000024100D0>
被斩
None
3，E
name = "颜良"
def outer(func):
def inner():
name = "马下"
func()
return inner
def show():
print(name) # 打印全局的
outer(show)()
输出：颜良
31，书写执行结果并解释每一步操作
#a
def outer(func, zy):
def inner(z):
return func(z)
return inner(zy)
def show(x):
return x * x
ret = outer(show, 9)
print(ret)
输出：81
解释：
def outer(func, zy):：定义了一个函数 outer，它接受一个函数 func 和一个参数 zy 作为参数。
def inner(z):：在 outer 函数内部定义了一个嵌套函数 inner，它接受一个参数 z。
return func(z)：在 inner 函数内部调用传入的 func 函数，并返回其结果。
return inner(zy)：outer 函数返回 inner 函数调用 zy 的结果。
def show(x):：定义了一个函数 show，它接受一个参数 x 并返回 x * x。
ret = outer(show, 9)：调用 outer 函数，并将 show 函数和参数 9 作为参数传入，结果赋值给 ret。
print(ret)：打印 ret。
#b
def outer(func, z, y):
return func(z, y)
def show(x):
return x * x
ret = outer(show, 9, 23)print(ret)
def outer(func, z, y):
return func(z, y)
f1 = lambda x, y: x + y
ret = outer(f1, 11, 23)print(ret)
解释：
def outer(func, z, y):：定义了一个函数 outer，它接受一个函数 func 和两个参数 z 和 y 作为参数。
return func(z, y)：在 outer 函数内部调用传入的 func 函数，并返回其结果。
def show(x):：定义了一个函数 show，它接受一个参数 x 并返回 x * x。
ret = outer(show, 9, 23)：调用 outer 函数，并将 show 函数和参数 9 和 23 作为参数传入，结果赋值给 ret。
print(ret)：打印 ret。
输出结果为：81
输出 81 是因为在 outer 函数内部调用了 show 函数，但 show 函数只接受一个参数，所以 23 被忽略，show 函数计算 9 * 9 并返回 81。
接下来是第二个代码块：
def outer(func, z, y):
return func(z, y)
f1 = lambda x, y: x + y
ret = outer(f1, 11, 23)
print(ret)
解释：
def outer(func, z, y):：定义了一个函数 outer，它接受一个函数 func 和两个参数 z 和 y 作为参数。
return func(z, y)：在 outer 函数内部调用传入的 func 函数，并返回其结果。
f1 = lambda x, y: x + y：定义了一个 lambda 函数 f1，它接受两个参数 x 和 y 并返回它们的和。
ret = outer(f1, 11, 23)：调用 outer 函数，并将 f1 函数和参数 11 和 23 作为参数传入，结果赋值给 ret。
print(ret)：打印 ret。
输出结果为：34
输出 34 是因为在 outer 函数内部调用了 f1 函数，f1 函数计算 11 + 23 并返回 34。
#c
def outer(func, z, y):
return func(z, y)
f1 = lambda x, y: x * y
ret = outer(f1, 11, 23)print(ret)
解释：
def outer(func, z, y):：定义了一个函数 outer，它接受一个函数 func 和两个参数 z 和 y 作为参数。
return func(z, y)：在 outer 函数内部调用传入的 func 函数，并返回其结果。
f1 = lambda x, y: x * y：定义了一个 lambda 函数 f1，它接受两个参数 x 和 y 并返回它们的乘积。
ret = outer(f1, 11, 23)：调用 outer 函数，并将 f1 函数和参数 11 和 23 作为参数传入，结果赋值给 ret。
print(ret)：打印 ret。
输出结果为：253
输出 253 是因为在 outer 函数内部调用了 f1 函数，f1 函数计算 11 * 23 并返回 253。
#32,
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
33、利用递归实现32题中c题的功能
def func(x, y=0):
y += 1
if y == 5:
return x + y
x += y
x = func(x, y)
x += y
return x
num = 1
result = func(num)
print(num)
print(result)
#34利用递归实现1*2*3*4*5*6*7=5040
d#1
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
result = factorial(7)
print(result)
#2
def func(x, y=1):
if x == 1:
return y
y = y * x
x -= 1
return func(x, y)
ret = func(7)
print(ret)
#3
from functools import reduce
print(reduce(lambda x, y: x * y, [x for x in range(1, 8)]))
35、写程序
a.文件操作时with 的作用?
whih 打开文件执行完毕后自动关闭
b.写程序:利用 with实现同时打开两个文件(一读，一写，并将读取的内容写入到写入模式的文件中)
with open("a", "r") as x, open("b", "w") as y:
y.write(x.read())
- 猴子第一天摘下若干个桃子，当即吃了-半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，还是不过瘾又多吃了一个。以后每天都吃前一天剩下的一半再加一个。到第10天刚好剩-一个。问猴子第一天摘了多少个桃子?1534
方法1
def calculate_peaches(days):
peaches = 1
for day in range(days, 1, -1):
peaches = (peaches + 1) * 2
return peaches
# 计算第一天摘了多少个桃子
first_day_peaches = calculate_peaches(10)
print(first_day_peaches)
方法2
s = 1
func = lambda x: (x + 1) * 2for i in range(9):
s = func(s)print(s)
方法3
def func(x, day):
day -= 1
if day == 0:
return x
x = (x + 1) * 2
ret = func(x, day)
return ret
ret = func(1, 10)print(ret)
标签：练习题,27,outer,name,Python,ret,func,print,def From： https://www.cnblogs.com/liu-zhijun/p/18379609