1,继续整理函数相关知识点，写博客。
2,写函数，接收n个数字，求这些参数数字的和。（动态传参）
3,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
a=10
b=20
def test5(a,b):
print(a,b)
c = test5(b,a)
print(c)
4,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
a=10
b=20
def test5(a,b):
a=3
b=5
print(a,b)
c = test5(b,a)
print(c)
print(a,b)
5,写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),将每个实参的每个元素依次添加到函数的动态参数args里面.
例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
6,写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}
7, 下面代码成立么?如果不成立为什么报错?怎么解决?
7.1
a = 2
def wrapper():
print(a)
wrapper() #成立
7.2
a = 2
def wrapper():
a += 1 # 不成立,Python规定 局部不能修改全局的变量,要修改需要使用global将变量引入
print(a)
wrapper()
7.3
def wrapper():
a = 1
def inner():
print(a) # 成立,局部可以调用全局的变量
inner()
wrapper()
7.4
def wrapper():
a = 1
def inner():
a += 1 # 不成立,内层修改外层的变量,需要nonlocal引入
print(a)
inner()
wrapper()
8，写函数,接收两个数字参数,将较小的数字返回.
9，写函数,接收一个参数(此参数类型必须是可迭代对象),将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回.
例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’
10,写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)
11,写函数，传入一个参数n，返回n的阶乘
例如:cal(7) 计算7*6*5*4*3*2*1
12写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
13 有如下函数:
def wrapper():
def inner():
print(666)
wrapper()
你可以任意添加代码,用两种或以上的方法,执行inner函数.
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
明日默写:
1，形参的接收顺序。
位置参数 > *args > 默认值参数 > **kwargs
2，什么是命名空间，什么是全局名称空间，什么是局部名称空间，什么是内置名称空间。
命名空间:用来存放名字(变量, 函数名, 类名, 引入的模块名)和值的关系的空间
1. 全局名称空间: 我们在py文件中自己写的变量, 函数(只是函数名自身不包括内部)
2. 内置名称空间: python解释器提供好的一些内置内容(print, input....)
3. 局部名称空间: 在我们执行函数的时候,会产生一个局部名称空间. 放的是: 函数内部的内容(变量, 函数,类...)
3，什么是全局作用域，什么是局部作用域。
全局作用域:在整个文件的任何位置都可以使⽤(遵循 从上到下逐⾏执⾏).
局部作⽤用域: 在函数内部可以使⽤用.
1. 全局作用域: 内置+全局
2. 局部作用域: 局部
5，解释一下什么是global，什么是nonlocal。
global: 在局部引入全局变量
nonlocal: 在局部...内层函数引入外层离他最近的那个(局部)变量.
# 参考答案
# t2
def func(*args):
sum = 0
for el in args:
sum += el
return sum
print(func(1, 2, 3))
# t3
a=20,b=10,c=None,因为c是函数的返回值,这里函数没有return,默认返回None
# t4
c = None,因为函数没有return. a = 10, b = 20
# t5
def func(*args):
return args
print(func(*[1, 2, 3], *(22, 33)))
# t6
def func(**kwargs):
return kwargs
print(func(**{'a': 'alex'}, **{'age': 1000})) # 这里的字典的键不能是纯数字,因为要打散成关键字参数,不能是 1 = a这种,传不到形参就不行了
# t7
# t8
def func(a, b):
return a if a < b else b
print(func(1, 2))
# t9
# 我写的 方法1
def func(args): # 使用动态传参的话会聚合成元组,元组不可变(比如:不可修改元素)
s = ''
for i in args:
s += str(i)+'_' # 拼接和累加 注意:字符串的索引是写在[]里面的
return s.strip('_') # s[:-1]
print(func([1,'老男孩','武sir']))
# 方法2:参考
def func(*args):
# lst = []
# for i in args:
# lst.append(str(i))
lst = [str(i) for i in args] # 同桌写的,相当于上面的三行
s = "_".join(lst)
return s
print(func(*[1, '老男孩', '武sir']))
'''
# join链接的可迭代对象的元素也必须是字符串
# print('_'.join([1,'老男孩','武sir'])) #报错:这里的第一个元素是int类型的 TypeError: sequence item 0: expected str instance, int found
# print('_'.join('12acd')) # 成功,这里面的数字是字符串
'''
# t10
def min_max(*args):
umin = min(args)
umax = max(args)
return {'max': umax, 'min': umin}
print(min_max(2, 5, 7, 8, 4))
# t11
def func(n):
fac = 1
for i in range(1, n + 1):
fac *= i
return fac
print(func(7))
# t12
def func():
lst1 = ['红心', '草花', '黑桃', '方片']
lst2 = []
for i in range(13):
for el in lst1:
lst2.append((el, i+1))
return lst2
print(func())
# t13
# t14-1
def calc(a,b,c,d=1,e=2):
return (a+b)*(c-d)+e
print(calc(1,2,3,4,5)) # 2
# print(calc(1,2)) # 这里报错,缺少一个位置参数'c'c
print(calc(e=4,c=5,a=2,b=3)) # 24
print(calc(1,2,3)) # 8
print(calc(1,2,3,e=4)) # 10
# print(calc(1,2,3,d=5,4)) # 这里的4报错,带等号的必须在最后边
# t14-2
def extendList(val,list=[]): # 函数调用没给默认值新值的情况下,多次调用使用同一个默认列表(即共享)
print(id(list)) # 默认值的内存
list.append(val)
return list
list1 = extendList(10)
print('list1=%s'%list1) # list1=[10] 添加完自己的就打印
print(id(list))
list2 = extendList(123,[])
print('list2=%s'%list2) # list2=[123]
print(id(list))
list3 = extendList('a')
print('list3=%s'%list3) # list3=[10, 'a'] 和第一个添加的是同一个列表
print('list1=%s'%list1) # list1=[10, 'a'] ##注意:第三个和第一个添加的是同一个列表
print('list2=%s'%list2) # list2=[123]
print('list3=%s'%list3) # list3=[10, 'a']
# t14-3
for i in range(1, 10):
for j in range(1, 10):
if j < i:
print(f'{i} * {j} = {i*j}', end=' ')
elif j == i:
print(f'{i} * {j} = {i*j}')
# t7-1
a = 2
def wrapper():
a = 5
def inner():
a = 3
a += 10
print(a)
inner()
wrapper() #成立
def func():
global a # 在局部引入全局变量, 如果这变量在全局不存在. 帮你创建一个全局变量
a = 10
print(a)
func()
print(a)
# 写函数，接收n个数字，求这些参数数字的和。（动态传参）
def func(*args):
sum = 0
for el in args:
sum += el
return sum
print(func(1,5,6,9,8,4,5,7))
# 写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),将每个实参的每个元素依次添加到函数的动态参数args里面.
# 例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
def func(*args):
print(args)
func(*[1,2,3], *(22,33))
def func(**kwargs):
print(kwargs)
func(**{"name":"李嘉诚", "age":123}, **{"address":"香港九龙"})
def wrapper():
global a # a 全局变量
a = 1
def inner():
nonlocal a # 局部
a+=1
print(a)
inner()
wrapper()
# 9，写函数,接收一个参数(此参数类型必须是可迭代对象),
# 将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回.
# 例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’
def func(lst):
s = ""
for el in lst:
s += str(el) + "_" # 拼接和累加
return s[:-1]
print(func([1,"胡辣汤", "朱祁镇"]))
# 写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
# 例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)
def func(*args):
return {'max':max(args),'min':min(args)}
print(func(1, 5, 7, 6, 5, 4, 2, 5, 8, 55, 4, 1, 2))
# 作业: 一个列表中的最大值
# 写函数，传入一个参数n，返回n的阶乘
# 例如:cal(7) 计算7*6*5*4*3*2*1
def func(n):
sum = 1
for i in range(n, 0, -1):
sum *= i
return sum
print(func(7))
# 写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
# 例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
def func():
hua = ["红心", "草花", "方块", "黑桃"] # 花色
dian = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# 笛卡尔积, 笛卡尔乘 -> 关系型数据库的原理
result = []
# 循环花色
for h in hua: # h就是花色: 红心
for d in dian: # d是每一个点数. A-K
result.append((h, d))
return result
print(func())
def wrapper():
def inner():
print(666)
# inner()
# inner = 10
return inner # 函数可以作为返回值返回
wrapper()()
print(ret)
def func():
return 123
a = func() + 10
print(a)
def wrapper():
def inner():
inner()
print(666)
wrapper()
'''
写代码完成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):
print("%s x %s = %s" % (i, j, i * j), end=" ")
print() # 换行
'''
*
**
***
****
*****
******
*
***
*****
*******
*********
***********
*
***
*****
*******
*********
***********
*********
*******
*****
***
*
'''
View Code
