10 函数进阶 知识点汇总
一.动态参数 形参的第三种
1.动态接收位置传参 表达:*args (在参数位置编写 * 表⽰接收任意内容)
(1)动态位置参数
def eat(*args):
print(args)
eat("水果","蔬菜","肉",)
# # 结果以元祖的形式呈现. : ('水果', '蔬菜', '肉')
(2) 位置参数,动态位置参数: 动态参数必须在位置参数后⾯
def eat(a,b,*args):
print(a,b,args)
eat("水果","蔬菜","鸡","鸭","鱼")
# # 结果 : 水果 蔬菜 ('鸡', '鸭', '鱼')
(3) 如果 "*args" ,位置参数,则后面的位置参数必须用关键字参数传值.
def eat(*args,a,b,):
print(args,a,b,)
eat("苹果","香蕉","梨","芒果",a="荔枝",b="樱桃")
# 结果 : ('苹果', '香蕉', '梨', '芒果') 荔枝 樱桃
(4).如果有默认值参数,则默认值参数必须写在动态参数之后才能生效.
def eat(a,b,*args,c=66):
print(a,b,args,c)
eat(1,2,3,4,5,6,7,8,)
# 结果: 1 2 (3, 4, 5, 6, 7, 8) 66
# 动态参数的顺序: 位置参数, 动态参数*, 默认值参数
2.动态接收关键字参数 表达:(**kwargs)
def fun(**kwargs):
print(kwargs)
fun(a=11,b=22,c=33)
# 结果以字典的形式呈现 ; {'a': 11, 'b': 22, 'c': 33}
# 动态接收关键字参数也要在后⾯
# 混合
def eat(a,b,*args,c=11,**kwargs):
print(a,b,args,c,kwargs)
eat("苹果","香蕉","橘子","荔枝","芒果","西瓜",d="火龙果")
# 动态参数的顺序:位置参数 ,动态接收位置参数 ,默认值参数,.动态接收关键字参数.
3.无敌传参: def fun(*args,**kwargs) 先位置后关键字
def fun(*args,**kwargs):
print(args,kwargs)
fun(1,2,3,4,a=33,b=44,c=55)
# 结果 (1, 2, 3, 4) {'a': 33, 'b': 44, 'c': 55}
4."动态参数的另一种传参方式
列表 (list)
def fun(*args):
print(args)
lst = [1, 4, 7]
fun(lst[0], lst[1], lst[2]) #或者下面的方式
fun(*lst) # 可以使⽤*把⼀个列表按顺序打散
字符串
s = "⾂妾做不到"
fun(*s)
字典 (dict)
def fun(**kwargs):
print(kwargs)
dic = {'a':1, 'b':2}
fun(**dic)
5.函数的注释
二.命名空间 : 我们给存放名字和值的关系的空间起⼀个名字叫: 命名空间
1.命名空间分类:
# (1).全局命名空间--> 我们直接在py⽂件中, 函数外声明的变量都属于全局命名空间
# (2) 局部命名空间--> 在函数中声明的变量会放在局部命名空间
# (3) 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间.
2.命名空间的加载顺序
# (1)内置命名空间;
# (2)全局命名空间:
# (3)局部命名空间 (函数被执行的时候)
3.命名空间的取值顺序;
# (1)局部命名空间
# (2)全局命名空间
# (3)内置命名空间
三.作用域: 作⽤域就是作⽤范围, 按照⽣效范围来看分为 全局作⽤ 域 局部作⽤域
1.全局作⽤域: 包含内置命名空间和全局命名空间. 在整个⽂件的任何位置都可以使⽤(遵循从上到下逐⾏执⾏)
2.局部作⽤域: 在函数内部可以使⽤.
3.globals()函数来查看全局作⽤域中的内容, locals()来查看局部作⽤域中的变量和函数信息
a = 10
def func():
a = 40
b = 20
def abc():
print("哈哈")
print(a, b) # 这⾥使⽤的是局部作⽤域
# print(globals()) # 打印全局作⽤域中的内容
# print(locals()) # 打印局部作⽤域中的内容
func()
四.函数的嵌套
1. 只要遇⻅了()就是函数的调⽤. 如果没有()就不是函数的调⽤
2. 函数的执⾏顺序
def fun1():
print(111)
def fun2():
print(222)
fun1()
fun2()
print(111)
# 结果:222,111,111
# 函数的嵌套
def fun2():
print(222)
def fun3():
print(666)
print(444)
fun3()
print(888)
print(33)
fun2()
print(555)
# 结果: 33,222,444,666,888,555
四.global and nonlocal
1.global表⽰. 不再使⽤局部作⽤域中的内容了. ⽽改⽤全局作⽤域中的变量
a = 100
def func():
global a # 加了个global表示不再局部创建这个变量了. ⽽是直接使⽤全局的a
a=28
print(a)
func()
print(a)
# 对于可变数据类型可以直接进⾏访问. 但是不能改地址. 说⽩了. 不能赋值
lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
def func():
lst.append("⻢云云") # 对于可变数据类型可以直接进⾏访问. 但是不能改地址. 说⽩了. 不能赋值
print(lst)
func()
print(lst)
2.nonlocal 表⽰在局部作⽤域中, 调⽤⽗级命名空间中的变量.
a = 10
def func1():
a = 20
def func2():
nonlocal a
a = 30
print(a)
func2()
print(a)
func1()
# j结果: 加了nonlocal 30 30
# 不加nonlocal 30 20
# 多层嵌套
a = 1
def fun_1():
a = 2
def fun_2():
nonlocal a
a = 3
def fun_3():
a = 4
print(a)
print(a)
fun_3()
print(a)
print(a)
fun_2()
print(a)
print(a)
fun_1()
print(a)
课后作业
9，写函数,接收一个参数(此参数类型必须是可迭代对象),将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回.
例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’
def func9(lst):
lst1=[]
for el in lst:
lst1.append(str(el))
return "_".join(lst1)
print(func9([1,'老男孩','武sir']))
10 写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)
def func10(*args):
the_max=args[0]
the_min=args[0]
for i in args:
if i < the_min:
the_min=i
elif i > the_max:
the_max=i
return {"max":the_max,"min":the_min}
print(func10(2,5,7,8,4))
方法二
def func10(*args):
dic={'max':max(*args),"min":min(*args)}
return dic
print(func10(2,5,7,8,4))
11 写函数，传入一个参数n，返回n的阶乘
例如:cal(7) 计算7*6*5*4*3*2*1
def cal(n):
sum=1
for i in range(n,0,-1):
sum=sum*i
return sum
print(cal(7))
12写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
def func():
lst=[]
li1=["红心","草花","黑桃","方片"]
li2 = [2, 3, 4, 5, 6, 7, 8, 9, 10, "J", "Q", "K", "A"]
for i in li1:
for el in li2:
lst.append(tuple([i,el]))
print(lst)
func()
13 # 写代码完成99乘法表.
for x in range(1,10):
for y in range(1,x+1):
r=x*y
print("%s * %s= %s " % (x,y,r)," ",end="")
print(end="\n")
