- 动态参数
- *args,动态位置参数接收到的是元组,使用时注意位置参数一定要在动态参数前面,否则位置参数的内容全部被动态参数接收
- **kwargs,动态关键字参数,接收到的是字典,使用时注意与默认值参数位置,默认值在**kwargs的前面
- 顺序: 位置参数>*args>默认值参数>**kwargs
- 在实参位置上*,**是代表把列表或者字典迭代打散
- 在形参位置,*,**是代表把位置参数,关键字参数聚合成一个列表,字典.
- 函数的注释,在函数内部输入"""+回车
- 命名空间
- 内置命名空间:存放Python为我们提供的名称空间,如:str,int,list,tuple等
- 全局命名空间:函数声明外为变量命名的空间
- 局部命名空间:在函数内部的空间
- 全局作用域:内置命名空间+全局命名空间 可用globals查询
- 局部命名空间:局部命名空间 可用locals查询
- 函数嵌套
- 函数里面可以分层级叠加使用函数,跟if语句相似
- 函数只有调用了才会执行 即出现()
- 注意执行顺序
- global和nonlocal
- global:在局部空间调用全局空间中的变量,可改变全局变量中的值
- nonlocal:只能在局部空间中使用,调用的也是相邻一级中的变量,如果相邻一级找不到再去上一级中寻找,但是最终只会寻找到全局变量中的下一层,不会到全局中寻找.
习题
# 2 写函数，接收n个数字，求这些参数数字的和。（动态传参）
# lst=[1,23,12,34,12,6,56,3,76]
# def sum(*args):
# num = 0
# for el in args:
# num = num + el
# return num
# print(sum(*lst))
# 3读代码，回答：代码中,打印出来的值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 程序在执行c = test5(b,a)时通过位置传参把全局空间中b,a 的值赋值给了局部空间中的a,b,
# 函数执行完毕打印出ab的值,程序在执行完c = test5(b,a)后,局部命名空间的变量的值清空,所以在全局命名空间中打印c为None
#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)
# 函数中打印的a=3,b=5全局空间中打印的a=10,b=20,c=None,函数中的ab属于局部命名空间,最后打印的ab属于全局命名空间
# 程序执行到print(c)的时候,c并没有返回值 所以为None
# 5
# 写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),
# 将每个实参的每个元素依次添加到函数的动态参数args里面.
# 例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
# lst=[1,2,3]
# tu=(22,33)
# z ="123jia"
# s={1,2,3,4,5}
# def die(*args):
# print(args)
# die(*lst,*tu,*z,*s)
# 6,写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面.
# 例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}
# dic = {'name':'alex','age':'102','sex':'未知'}
# def dit(**kwargs):
# print(kwargs)
# dit(**dic)
#7, 下面代码成立么?如果不成立为什么报错?怎么解决?
#7.1
# a = 2
# def wrapper():
# print(a)
# wrapper()
# 成立 局部空间可以用全局空间中的变量
#7.2
# a = 2
# def wrapper():
# a += 1
# print(a)
# wrapper()
# #UnboundLocalError: local variable 'a' referenced before assignment
# 局部空间可以调用全局空间中的变量,但是么有global不能赋值,因为没有创建新的变量a
# #7.3
# def wrapper():
# a = 1
# def inner():
# print(a)
# inner()
# wrapper()
# 可以 局部空间中优先调用就近一层中的变量
# #7.4
# def wrapper():
# a = 1
# def inner():
# a += 1
# print(a)
# inner()
# wrapper()
#错误 局部变量赋值之前要先进行创建a
# 8，写函数,接收两个数字参数,将较小的数字返回.
# a=input("请输入数字a:")
# b=input("请输入数字b")
# def compare(a,b):
# return a if a>b else b
# print(compare(a,b))
# 9，写函数,接收一个参数(此参数类型必须是可迭代对象),将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回.
# 例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’
# lst = [1,'老男孩','武sir']
# def y(*args):
# s = ""
# for el in args:
# s=s+str(el)+"_"
# print(s.strip("_"))
# y(*lst)
# 10
# 写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
# 例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)
# def sun(*args):
# dic = {}
# dic['max']=max(args)
# dic['min']=min(args)
# print(dic)
# sun(2,5,7,8,4)
# 11
# 写函数，传入一个参数n，返回n的阶乘
# 例如:cal(7) 计算7*6*5*4*3*2*1
# def cal (s):
# if s ==0:
# return True
# else:
# return s*cal(s-1)
# print(cal(4))
# 12写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
# 例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
#
# def pu():
# l = ['红心','草花','黑桃','方片']
# l1 = ['A',1,2,3,4,5,6,7,8,9,'J','Q','K']
# l2 = []
# for i in l:
# for el in l1:
# l2.append((i,el))
# print(l2)
# pu()
# 14 有如下函数:
# def wrapper():
# def inner():
# print(666)
# wrapper()
# 你可以任意添加代码,用两种或以上的方法,执行inner函数.
# 1
#def wrapper():
# def inner():
# print(666)
# inner()
# wrapper()
# 2
# def wrapper():
# # def inner():
# # print(666)
# # return inner()
# # wrapper()
# 1，有函数定义如下：
# def calc(a,b,c,d=1,e=2):
# return (a+b)*(c-d)+e
# 请分别写出下列标号代码的输出结果，如果出错请写出Error。
# print(calc(1,2,3,4,5)) # 2
# print(calc(1,2)) #error
# 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))__error___
# 2，(此题有坑)下面代码打印的结果分别是_list1=[10,'a'],list=[123],list3=[10,'a'].
# def extendList(val,list=[]):
# list.append(val)
# return list
# list1 = extendList(10,)
# list2 = extendList(123,[])