# 今天内容
# 复习
def fn(a,b):
# print(a,b)
return a+b
# print(fn(10,20))
def add():
res=fn(10,20)#将fn(a,b)的结果赋值给res
print(res)
add()#想要函数运行，必须将函数调用
# 函数的四个组成部分
# 函数名：调用函数的依据，必须的
# 函数体：执行函数逻辑的
# 函数参数：是为函数内体提供函数资源，只有有资源，才能进行运算
# 函数值：返回函数结束以后的一个你想要的值，也就是你运行函数的初衷，一般都只有一个值
# 函数返回值：空返回（没有return|空return），一值返回|多值返回（是以元组返回）
# 实参：外界调用函数的依据，拥有实际值
# 形参：是用来接受实参传入的值，形参是对实参值的拷贝
l=[1,2,3,4]
num=10
def fn(args,n):
args[1]=200
print(id(l))#2202093707912 在函数被销毁之前就已经更改，所以退出后不会改变
print(id(n))#140736006710384 10的函数地址
n=100
print(id(n))#140736006713264
fn(l,num)
print(id(l))#2202093707912 l改变的原因是list是可变类型，args[1]就是更改了l的原值，所以l改变
print(id(num))#140736006710384 10的函数地址，更改不成功的原因是因为整数是不可变类型
d={'egon':11,'owen':15}
l=['a','s',123]
def fn(x,y):
x['owen']='bigman'
print(id(x))#64 字典列表都是可变类型，所以id不会改变
y[1]='sdff'
print(id(y))#92
fn(d,l)
print(id(d))#64
print(id(l))#92
a=1000
b=30001.2
def m(x,y):
a=100
print(id(a))#264
b=200
print(id(b))#464
m(a,b)
print(id(a))#48 整形和浮点型都是不可变类型，所以在函数内更改id会发生改变
print(id(b))#16
# 实参的分类
# 位置实参和关键字实参
# 位置实参必须在关键字实参之前，可以给位置形参传值，默认形参，可变长位置形参
# 关键字实参可以给任意形参传值
#
# 形参是对实参的值的一个拷贝，实参可以按照位置和关键字对形参进行传值
# 四则运算
def add(a,b):
return a+b
def low(a,b):
return a-b
def jump(a,b):
return a/b
def full(a,b):
return a*b
def quyu(a,b):
return a%b
def computed(fn,n1,n2):
res=fn(n1,n2)#fn就是四则运算的功能
return res
method_map={'add':add,
'low':low,
'jump':jump,
'full':full,
'quyu':quyu,
}
# 根据指令获取计算方法
def get_cp_fn(cmd):#cp_fn()就是fn的一个值复制
if cmd in method_map:
return method_map[cmd]
return add
while True:
cmd=input('cmd:')
if cmd=='quit':
break
cp_fn=get_cp_fn(cmd)
restult=computed(cp_fn,100,20)
print(restult)
# 作为一个容器类型的元素
def add(n1,n2):
return a+b
def low(n1,n2):
return a-b
def jump(n1,n2):
return a*b
def computed(func,n1,n2):
res=func(n1,n2)
return res
method_map={'add':add,
'low':low,
'jump':jump,
}
while True:
cmd=input('cmd:')
if cmd in method_map:
cp_func=method_map[cmd]
print(res)
else:
print('输入有误，重新输入')
break
# 4可以作为函数的返回值
def add(n1,n2):
return a+b
def low(n1,n2):
return a-b
def jump(n1,n2):
return a*b
def full(n1,n2):
return a/b
def quyu(n1,n2):
return a%b
def computed(func,n1,n2):
res=func(n1,n2)
return res
method_map={'add':add,
'low':low,
'jump':jump,
'full':full,
'quyu':quyu,
}
def get_cp_func(cmd):
if cmd in method_map:
return method_map[cmd]
return add
while True:
cmd=input('cmd:')
if cmd=='quit':
break
cp_func=get_cp_func(cmd)
restult=computed(cp_func,100,20)
print(restult)
# 2.名称空间
print(len('abc'))
len=len('acddj')
print(len)
del len
print(len('sfsfsdfeffdf'))
# 具体应用
def fn():
len=10
print(len)
def fn2():
len=20
print(len)
# 3函数的嵌套
l=[]
def fn1():
l=[]
l.append(100)#[100]
print(l)
fn()
print(l)#[]
# 3.2global的应用
def fn():
global num #global只能放到上面
num=20
global num
num=10
print(num)
fn()
print(num)
# 3.3定义一个函数，函数中有一个变量
def fn():
num=20
def fn2():
print(num)
num=fn2()#令num等于fn2(),就可以直接调用fn2()
fn2()
# 3.4将函数直接定义到另一个函数中，就可以使用外部函数的名字
def fn4():
num=20
def fn5():
print(num)#20
fn5()
fn4()
# 4作用域
# 名字起作用的范围，作用：解决名字可以共存的问题
len=10
def outer():
len=20
def inner():
len=30
print('1:',len)#30
inner()
print('2:',len)#20
outer()
print('3:',len)#10
del len
print('4:',len)#build-in
# 5闭包
def outer():
num=10
def inner():
print(num)
return inner
fn=outer
fn()
# 闭包案列
import time
def download():
print('开始下载')
time.sleep(2)
print('下载完成')
data='下载得到的信息'
outer(data)
def outer(data):
def inner():
print('闭包打印：',data)
inner
download()
# 结果：闭包打印：下载得到的数据
# 案列二：延迟执行
