1.列举布尔值为False的值
0,False,None,"",[],(),{}
2.写函数：根据范围获取其中3和7整除的所有数的和，并返回调用者：符合条件的数字个数以及符合条件的数字的总和，如：def
func(start,end)：
def func(start,end):
count=0
s=0
for i in range(start,end):
if i%3==0 and i%7==0:
count+=1
s+=i
print(i)
return s,count
print(func(0,100))3.函数的默认返回值
None
4.简述break/continue/return的区别：
break:结束当前循环
continue:结束本次循环进入下一次循环
return:结束函数，并返回结果(默认为None)
5.函数传递参数时，是引用还是复制值，并证明
是引用
def test(a):
print(id(a))
b=1
print(id(b))
test(b) #两次内存id相同6.简述三元运算书写格式及应用场景 #"元"意为运算符
变量=值1 if 条件1 else 值2
简写简单的条件判断
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.定义函数统计一个字符串中大写字母、小写字母、数字的个数，并以字典为结果返回
提示：可以用id进行判断
d={'Al':0,'low':0,'num':0}
def tongji(s):
for i in s :
if i.isupper():
d.update(Al=d.get('Al')+1)
elif i.islower():
d.update(low=d.get('low') + 1)
elif i.isnumeric():
d.update(num=d.get('num')+1)
return d
t=tongji('Manuel123')
print(t)def num(st):
a = 0
b = 0
c = 0
for i in st:
if i.isupper(): #判断是否是大小字母
a += 1
elif i.islower(): #判断是否是小写字母
b += 1
elif i.isdigit(): #判断是否是数字
c += 1
return a, b, c,
sf = "sefisehfi294723dASE"
cc = num(sf)
print(cc)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,2,3)
#结果为1,3,2
c.
def func(x,y,*z):
print(x,y,z)
func(1,2,3,4,5,6)
#结果为1,2,(3,4,5,6,)
d.
def func(x,y,*z):
print(x,y,z)
func(1,2,3,4,5,6,6)
#结果为1,2,(3,4,5,6,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,(),{'name':2,'age':3}
g.
def func(x=2,*y,**z):
pirnt(x,y,z)
func(name=2,age=3)
#结果为2,(),{'name':2,'age':3}
h.
def func(*y,**z):
print(y,z)
func([1,2,3,4,5])
#结果为([1,2,3,4,5],){}
i.
def func(*y,**z):
print()
func(*[1,2,3,4,5])
#结果为(1,2,3,4,5,){}
j.
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}
k.
def func(*y,**z):
pirnt(y,z)
func(*[1,2,3,4,5],{'name':'alex','age':19})
#结果为(1,2,3,4,5,{'name':'alex','age':19}){}
l.
def func(*y,**z):
pirnt(y,z)
func(*[1,2,3,4,5],**{'name':'alex','age':19})
#结果为(1,2,3,4,5,){'name':'alex','age':19}
m.
b='oldboy%d%%'%(12,)
print(b)
#结果为oldboy12%13.书写输出结果(禁止运行代码)
a.
def func(*y,**z):
print(y,z)
func(1,2,3,4,5)
输出结果为：1 (1, 2, 3, 4, 5) {}
b.
def func(*y,**z):
print(y,z)
func([1,2,3,4,5])
输出结果为：1 ([1, 2, 3, 4, 5],) {}
c.
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5])
输出结果为：1 (1, 2, 3, 4, 5) {}
d.
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5],name="alex",age=19)
输出结果为：1 (1, 2, 3, 4, 5) {'age': 19, 'name': 'alex'}
e.
def func(x,*z,**y):
print(x,y,z)
func(1,2,3)
输出结果为：1 1 {} (2, 3)
f.
def func(*y,**z):
print(y,z)
func(*[1,2,3,4,5],**{"name":"alex","age":19})
输出结果为：1 (1, 2, 3, 4, 5) {'age': 19, 'name': 'alex'}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'}
()
None15.书写执行结果（禁止运行代码）
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]
None16.书写执行结果（禁止运行代码）
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
None17.简述 Python3 中的 range 函数和 Python2.7 中的 range 函数有什么区别?
答：区别：在于返回值的不同
python3.x range 不会生成值，只有用的时候才会生成
python2.7.x range 会直接生成一个列表，值已经生成
区别示例：
python2.x中的range返回的是一个列表
>>> range(1,10) #打印出1-10的数字，python默认从0开始
[1, 2, 3, 4, 5, 6, 7, 8, 9]python3.x中的range返回的是一个迭代值
#错误的方法
>>> range(1,10)
range(1, 10)#正确的方法，要想打印出列表，需要加list
>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]18.书写执行结果（禁止运行代码）
a、
a="oldboy%"
print(a)
输出结果为：1 oldboy%
b、
b="oldboy%d%%"%(12,)
print(b)
输出结果为：1 oldboy12%19、简述对象和类的关系
如果值是某类型，那这个值就是这个类的对象
20、书写执行结果（禁止运行代码）
def func(a1):
return a1 + 100 #func值被系统垃圾回收机制回收。
func = lambda a1:a1 + 200
def func(a1)
return a1 + 200 #下面这个func覆盖掉上面那个a1的值=a1+200=210
ret = func(10)
print(ret)
输出结果为：21021.内置函数all和any的区别
all:如果为空，则为真，如果非空，全真则为真
any:有一个为真则为真
22.简述文件打开模式‘r’和‘rb’的区别
‘r’：只读模式，解码方式默认为‘utf-8’
‘rb’：以二进制方式读文件,通常处理非txt文件
23.将‘老男人’转换成utf-8编码的字节类型
a='老男人'
b=a.encode('utf8')
c=bytes(a,'utf8')
print(b)
print(c)24、利用内置函数将十进制数字12，分别转换成二进制、八进制、十六进制表示的字符串
print(bin(12)) #二进制
print(oct(12)) #八进制
print(hex(12)) #十六进制
执行结果：
0b1100 #二进制
0o14 #八进制
0xc #十六进制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(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)]
n1 = list(zip(l1,l2,l3,l4))
n2 = n1[0]
n3 = '_'.join(n2)
print(n3)print("_".join(list(zip(l1,l2,l3,l4))[0]))27.判断输出结果是否相同？并可得到什么结论？
def f1(arg):
print(id(arg))
n=1111111
print(id(n))
f1(n)相同,均为11277024；函数实参是在引用值
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)
#结果为:D:/python/job8/job.py:335: SyntaxWarning: name 'NAMELIST' is assigned to before global declaration global NAMELIST29.书写执行结果（禁止运行代码）
a.
name = "root"
def func():
name = "seven"
def outer(): #outer()未运行
name = "eric"
def inner(): #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)
#结果为：
eric
None
seven
None
root30.书写执行结果并解释每一步操作
a.
name = "苍老师"
def outer(func):
name = 'alex'
func()
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)
result = ret()
print(result)
#结果为：
波多
<function outer.<locals>.inner at 0x01225660> #inner内存地址
波多
None
d.
name = "苍老师"
def outer():
name = "波多"
def inner():
print(name)
return inner
ret = outer()
print(ret)
result = ret()
print(result)
#结果为：
<function outer.<locals>.inner at 0x01715660>
波多
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)
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)
#结果为3432.写输出结果
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
d.
def fnuc(x,y=0):
y += 1
if y == 5:
return x + y
x += y
func(x,y)
x += y
return x
num = 1
result = fnuc(num)
print(num)
print(result)33.利用递归实现1234567
#参数t保存每次计算的结果，n保持递增，然后进行计算
def func(n,t):
t=t*n
if n>=7:
return t
n+=1
return func(n,t)
print(func(2,1)) #结果为5040from functools import reduce
print(reduce(lambda x,y:x*y,[x for x in range(1,8)])) #结果为504034.写程序
a.利用filter、自定义函数获取 l1 中元素大于 33 的所有元素l1=
[11,22,33,44,55]
def f1(args):
if args>33:
return True
l1 = [11,22,33,44,55]
ret = filter(f1,l1)
print(list(ret)) #结果为1 [44,55]l1 = [11,22,33,44,55]
print(list(filter(lambda x:x>33,l1))) #结果为1 [44,55]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))) #结果为1 [11,22]c.利用map、自定义函数将所有是奇数的元素加 100
l1=[11,22,33,44,55]
d.利用map、lambda 表达式将所有是偶数的元素加 100
l1=[11,22,33,44,55]
35.写程序
a.文件操作时 with 的作用？
whih 打开文件执行完毕后自动关闭
b.写程序：利用 with 实现同时打开两个文件（一读，一写，并将读取的内容写入到写入模式的文件中）
with open("a", "r") as x, open("b","w") as y:
y.write(x.read())36.写函数：
如有以下两个列表
l1=[…]
l2=[]
第一个列表中的数字无序不重复排列，第二个列表为空列表
需求：
取出第一个列表的最小值放到第二个列表的首个位置，
取出第一个列表的最小值（仅大于上一次的最小值）放到第二个列表的首个位置，
取出第一个列表的最小值（仅大于上一次的最小值）放到第二个列表的首个位置，
…
依此类推，从而获取一个有序的列表 l2，并将其返回给函数调用者。
deffunc(l1,l2):
pass
l1 = [11,33,44,2,66]
l2 = []
def foo(x,y):
for item in range(len(x)):
v = min(x)
y.insert(0,v)
x.remove(v)
return y
print(foo(l1,l2))37.猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，还是不过瘾又多吃了一个。以后每天都吃前一天剩下的一半再加一个。到第 10 天刚好剩一个。问猴子第一天摘了多少个桃子？
解题思路：
这题得倒着推。第10天还没吃，就剩1个，说明第9天吃完一半再吃1个还剩1个，假设第9天还没吃之前有桃子p个，可得：p * 1/2 - 1 = 1，可得 p = 4。以此类推，即可手算出。
代码思路：第10天还没吃之前的桃子数量初始化 p = 1，之后从9至1循环9次，根据上述公式反推为 p = (p+1) * 2 可得第1天还没吃之前的桃子数量。for循环中的print()语句是为了验证推算过程而增加的。
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)def func(x, day):
day -= 1
if day == 0:
return x
x = (1 + x) * 2
ret = func(x, day)
return ret
ret = func(1, 10)
print(ret)
