1.
1.作业
1,写函数，接收n个数字，求这些参数数字的和。（动态传参） 2,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
a=10
b=20
def test5(a,b):
print(a,b)
c = test5(b,a)
print(c) 3,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
a=10
b=20
def test5(a,b):
a=3
b=5
print(a,b)
c = test5(b,a)
print(c)
4,写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),将每个实参的每个元素依次添加到函数的动态参数args里面.
例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33) 5,写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}
6, 下面代码成立么?如果不成立为什么报错?怎么解决?
6.1
a = 2
def wrapper():
print(a)
wrapper() 6.2
a = 2
def wrapper():
a += 1
print(a)
wrapper()
6.3
def wrapper():
a = 1
def inner():
print(a)
inner()
wrapper()
6.4
def wrapper():
a = 1
def inner():
a += 1
print(a)
inner()
wrapper() 7，写函数,接收两个数字参数,将较小的数字返回. 8，写函数,接收一个参数(此参数类型必须是可迭代对象),将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回.
例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’ 9,写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数) 10,写函数，传入一个参数n，返回n的阶乘
例如:cal(7) 计算7*6*5*4*3*2*1 11.写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组（升级题）
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)] 12.有如下函数:
def wrapper():
def inner():
print(666)
wrapper() 你可以任意添加代码,用两种或以上的方法,执行inner函数.
2.
2.默写
1，形参的接收顺序。
2，什么是命名空间，什么是全局名称空间，什么是局部名称空间，什么是内置名称空间。
3，什么是全局作用域，什么是局部作用域。
4，名称空间的加载顺序，取值顺序。
5，解释一下什么是global，什么是nonlocal。
答案
1.写函数，接收n个数字，求这些参数数字的和。（动态传参）
def sum_func(*args):
total = 0
for i in args:
total += i
return total
print(sum_func(1,2,3,8,23,6))
2,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
a=10
b=20
def test5(a,b):
print(a,b)
c = test5(b,a)
print(c) ----------------------
结果：
a = 20
b = 10
c = None
3,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
a=10
b=20
def test5(a,b):
a=3
b=5
print(a,b)
c = test5(b,a)
print(c)
--------------------------
结果：
a = 3
b = 5
c = None
4,写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),将每个实参的每个元素依次添加到函数的动态参数args里面.
例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
def sum(*objs):
lis=[]
for i in objs:
for ii in i:
lis.append(ii)
return lis
ret=sum([1,2,3], (22,33))
print(ret)
5,写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}
def dic_to_sum(**kwargs):
return kwargs
ret=dic_to_sum(**{"name":"alex"},**{"age":1000})
print(ret)
6, 下面代码成立么?如果不成立为什么报错?怎么解决?
7.1
a = 2
def wrapper():
print(a)
wrapper()
7.2
a = 2
def wrapper():
global a#增加此行代码
a += 1#报错,不能修改直接修改全局变量
print(a)
wrapper()
print(a)
7.3
def wrapper():
a = 1
def inner():
print(a)
inner()
wrapper()
7.4
def wrapper():
a = 1
def inner():
nonlocal a#增加此行代码
a += 1#报错,不能修改直接修改上层的局部变量
print(a)
inner()
wrapper()
8，写函数,接收两个数字参数,将较小的数字返回.
def comper(num1,num2):
return num1 if num1>num2 else num2
ret=comper(99,98)
print(ret)
9，写函数,接收一个参数(此参数类型必须是可迭代对象),
将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回.
例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’
def hebin(*args):
s=""
for el in args:
s = s + str(el) + "_"
s = s[:-1]
return s
dic=[1,"老男孩","武sir"]
ret=hebin(*dic)
print(ret)
10,写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)
def min_max(*args):
dic={}
dic["max"]=max(args)
dic["min"]=min(args)
return dic
ret=min_max(2,5,7,8,4)
print(ret)
11,写函数，传入一个参数n，返回n的阶乘
例如:cal(7) 计算7*6*5*4*3*2*1
def factorial(n):
for i in range(1,int(n)):
n = n * i
print(n)
ret=factorial(7)# 7 ret=5040
print(ret)
12写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
def pai():
se=["黑桃", "红桃", " 棉花", " 方块"]
num=['A',2,3,4,5,6,7,8,9,10,'J','Q','K']
s = ""
result = []
for ii in num:
for i in se:
s = (str(i), str(ii))
result.append(s)
return result
print(pai())
print(len(pai()))
14相关面试题（先从纸上写好答案，然后在运行）：
1，有函数定义如下：
def calc(a,b,c,d=1,e=2):
return (a+b)*(c-d)+e
请分别写出下列标号代码的输出结果，如果出错请写出Error。
print(calc(1,2,3,4,5))_____
print(calc(1,2))____
print(calc(e=4,c=5,a=2,b=3))___
print(calc(1,2,3))_____
print(calc(1,2,3,e=4))____
print(calc(1,2,3,d=5,4))_____
2，(此题有坑)下面代码打印的结果分别是_________,________,________.
def extendList(val,list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a') print('list1=%s'%list1)
print('list2=%s'%list2)
print('list3=%s'%list3)
3, 写代码完成99乘法表.(升级题)
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
......
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
#乘法表
for i in range(1,10):#
for j in range(1,i+1):#
if i ==j:
print("%s*%s=%s"%(j,i,i*j),"n")
else:
print("%s*%s=%s"%(j,i,i*j),end=" ")
默写
默写:
1，形参的接收顺序。
位置参数 => *args => 默认值参数 => **kwargs 2，什么是命名空间，什么是全局名称空间，什么是局部名称空间，什么是内置名称空间
命名空间:存放名字和值的关系的空间
全局名称空间: 在代码运行初始,(俗称函数外)创建的存储名字和值的空间
局部名称空间: 函数运行中创建的空间
内置名称空间: python解释器内部运行时存储的:int,str,list,tuple这些名字的空间 3，什么是全局作用域，什么是局部作用域。
全局作用域: 包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域: 局部名称空间，只能在局部范围内生效 4，名称空间的加载顺序，取值顺序。
加载顺序:内置命名空间(程序运行前加载)=>全局命名空间(程序运行中:从上到下加载)=>局部命名空间(程序运行中:调用时才加载)
调用顺序:
在局部调用：局部命名空间->全局命名空间->内置命名空间
在全局调用：全局命名空间->内置命名空间 5，解释一下什么是global，什么是nonlocal。
global: 把全局变量拿到局部来用.
nonlocal: 在函数内部中,把最近的一层的变量拿过来.不会找全局