python--函数的返回值、函数参数的使用、名称空间与作用域、函数嵌套、函数对象
今天学习内容有函数的返回值、函数参数的使用、名称空间与作用域、函数嵌套。
下来我们一一查看。
函数的返回值
看几个栗子：
def func(x): return x**2 y=func(10) print(y)
def foo(): return None res=foo() print(res)
def foo(): return{'a':1} res=foo() print(res['a'])
def foo(): return {'a':1},1,'a',[1,2] res=foo() print(res)
结果：({'a': 1}, 1, 'a', [1, 2])
def foo(): return 1 print('======>') return 2 return 3 return 4 print(foo())
结果：1
下面我们来总结一下返回值的效果：
'''
返回值：可以返回任意类型
没有return：默认返回None
return value: value
return val1,val2,val3 :(val1,val2,val3) 返回元祖类型
return的效果：只能返回一次值，终止函数的执行
'''
函数参数的使用
def foo(x): print(x) foo(1) foo('a') foo({'a':2})
结果：
1
a
{'a': 2}
#形参与实参： def foo(x,y): return x+y print(foo(1,2))
结果：3
位置参数：按照从左到右的顺序依次定义的参数
- 按位置定义的形参,必须被传值，多一个不行，少一个也不行
- 按位置定义的实参,与形参一一对应
关键字参数：实参在定义时，按照key=value形式定义
- #关键字参数可以不用像位置实参一样与形参一一对应，指名道姓地传值
def foo(x,y): print(x) print(y) foo(y=1,x=10) 结果： 10 1
def foo(x,y,z): print(x) print(y) print(z) foo(1,y=2,z=10) 结果： 1 2 10
- 注意的问题一：位置实参必须在关键字实参的前面
- 注意的问题二：实参的形式既可以用位置实参又可以是关键字实参，但是一个形参不能重复传值
默认参数：在定义函数阶段，就已经为形参赋值,定义阶段有值，调用阶段可以不用传值
def func(x,y=10): print(x) print(y) func(1,20) func(1) 结果： 1 20 1 10
- 默认参数需要注意的问题一：必须放在位置形参后面
- 默认参数需要注意的问题二：默认参数通常要定义成不可变类型
- 默认参数需要注意的问题三：默认参数只在定义阶段被赋值一次
形参的应用：值经常变化的需要定义成位置形参
值大多数情况下都一样，需要定义成默认参数
可变长参数：可变长指的是实参的个数不固定
- 按位置定义的可变长度的实参：*
- 按关键字定义的可变长度的实参：**
def func(x,y,*args): #x=1,y=2,args=(3,4,5,6) print(x,y) print(args) func(1,2,3,4,5,6) 结果： 1 2 (3, 4, 5, 6)
def func(x,y,*args): #args=(3,4,5,6) print(x,y) print(args) func(1,2,*(3,4,5,6)) #foo(1,2,3,4,5,6) 结果： 1 2 (3, 4, 5, 6)
def func(x,y,**kwargs): #x=1,y=2,kwargs={'a':1,'b':3,'z':3} print(x,y) print(kwargs) func(1,y=2,z=3,a=1,b=3) 结果： 1 2 {'z': 3, 'a': 1, 'b': 3}
def func(x,y=1,z=1): print(x,y,z) func(**{'y':2,'x':1,'z':3}) 结果： 1 2 3
def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数 print(args) print(kwargs) wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)
命名关键字参数:定义在*后的形参，这类形参，必须被传值，而且要求实参必须是以关键字的形式来传值
def register(name,age,*,group,**kwargs): print(name) print(age) print(kwargs) print(group) register('egon',18,group='group1',hobby='play') 结果： egon 18 {'hobby': 'play'} group1
def register(**kwargs): print(kwargs) if 'name' in kwargs: print(kwargs['name']) if 'age' in kwargs: print(kwargs['age']) register(name='egon',age=18) register() 结果： {'name': 'egon', 'age': 18} egon 18 {}
def register(*args,name='egon',age): print(args) print(name) print(age) register(name='alex',age=18) register(1,2,3,3,age=10) 结果： () alex 18 (1, 2, 3, 3) egon 10
引用形参顺序：位置形参，默认参数，*args，命名关键字参数，**kwargs
名称空间与作用域
名称空间：存放名字与值的绑定关系
名称空间分为三种：
- 内置名称空间：python解释器自带的名字，python解释器启动就会生成
- 全局名称空间：文件级别定义的名字都会存放与全局名称空间，执行python文件时会产生
x=1
def func():
pass
class Foo:
pass
import os
if 1 > 2 :
y=3
- 局部名称空间：定义在函数内部的名字，局部名称空间只有在调用函数时才会生效，函数调用结束则失效
三者的加载顺序：内置名称空间->全局名称空间->局部名称空间
取值：局部名称空间->全局名称空间->内置名称空间
max=10 def func(): max=20 print(max) func() 结果： 20
max=10
def func():
# max=20
print(max)
func()
结果：
10
x=0 def f1(): x=1 def f2(): x=2 def f3(): x=3 print(x) f3() f2() f1() 结果： 3
作用域：作用范围
全局作用域：内置名称空间与全局名称空间的名字属于全局范围，在整个文件的任意位置都能被引用，全局有效
局部作用域：局部名称空间的名字属于局部范围，只在函数内部可以被引用，局部有效
x=1 def foo(): def f2(): print(x) f2() def bar(): print(x) foo() bar() 结果： 1 1
def f1(): x=1 def f2(): x=2 print(x) f2() f1() 结果： 2
函数嵌套
函数的嵌套调用
def max2(x,y): if x > y: return x else: return y def max4(a,b,c,d): res1=max2(a,b) res2=max2(res1,c) res3=max2(res2,d) return res3 print(max4(11,23,-7,31)) 结果： 31
函数的嵌套定义
def f1(): def f2(): def f3(): print('from f3') print('from f2') f3() print('from f1') f2() # print(f1) f1() 结果： from f1 from f2 from f3
函数对象
函数是第一类对象： 指的是函数可以被当做数据传递
def func():
print('from func')
#可被引用
# f=func
#可以当做函数的参数
def func(): print('from func') def foo(x): print(x) x() foo(func) 结果： C:\Users\Administrator\AppData\Local\Programs\Python\Python36\python.exe C:/Users/Administrator/PycharmProjects/untitled/课堂练习.py <function func at 0x00000000005D3E18> from func Process finished with exit code 0
#可以当做函数的返回值
def foo(): print('from foo') def bar(): return foo f=bar() print(f) print(foo) 结果： C:\Users\Administrator\AppData\Local\Programs\Python\Python36\python.exe C:/Users/Administrator/PycharmProjects/untitled/课堂练习.py <function foo at 0x0000000001D73E18> <function foo at 0x0000000001D73E18> Process finished with exit code 0
x=0 def f1(): x=1 def f2(): # x=2 print(x) return f2 f=f1() # print(f) f() 结果： 1
#可以当做容器类型的元素
def select(): print('select function') func_dic={ 'select':select, } # print(func_dic['select']) func_dic['select']() 结果： select function
def select(): print('select func') def delete(): print('delete func') def change(): print('change func') def add(): print('add func') while 1: cmd=input('>>: ').strip() if not cmd: continue if cmd == 'select': select() elif cmd == 'delete': delete() elif cmd == 'change': change() elif cmd == 'add': add() else: print('无效的命令')
def select(cmd_l):
filename=cmd_l[-1]
pattern=cmd_l[1]
with open(filename,'r',encoding='utf-8') as f:
for line in f:
if pattern in line:
print(line)
def delete():
print('delete func')
def change():
print('change func')
def add():
print('add func')
def check():
print('check func')
func_dic={
'select':select,
'delete':delete,
'change':change,
'add':add,
'check':check,
}
while 1:
inp=input('>>: ').strip()
if not inp:continue
cmd_l=inp.split()
# print(cmd_l)
cmd=cmd_l[0]
if cmd in func_dic:
func_dic[cmd](cmd_l)
else:
print('无效的命令')
