函数
1.
必须遵循的原则： 先定义，再使用 ，函数的定义，与变量的定义相似，
在定义函数阶段，只检测语法，不执行代码，
如果语法错误，也不能执行，如果逻辑有错误，也不能执行
只要定义了，不管在哪都可以执行，
只有在函数名加括号的时候在执行
结果
-----------------------------------------------------------------------------------------
2.
函数返回值
函数体最终要有一个结果，返回回来，要加return，
有参数函数，要有返回值，
返回值：可以返回任意类型
没有return：None
return value: value
return val1,val2,val3 :(val1,val2,val3)--返回多个值，是元组形式
return的效果：只能返回一次值，终止函数的执行
def foo():
return 1 -----只返回到return1 ，返回值为 1 ，只能执行一个return，返回一个值，
print('=====>')
return 2
return 3
return 4
print(foo())
-----------------------------------------------------------------------------------------
3.位置参数与关键字参数
形参与实参：
def foo(x,y): -----形参 就是变量名，
return x+y
foo(1,2) -----实参， 就是值，
x=1,y=2 在函数调用阶段，还是有效
4.
#===================================part1
#位置参数：按照从左到右的顺序依次定义的参数
def foo(x,y): ----#按位置定义的形参,必须被传值，多一个不行，少一个也不行
print(x)
print(y)
# foo(2,10)
#按位置定义的实参,与形参一一对应 x=2,y=10
5.
#关键字参数：实参在定义时，按照key=value形式定义
# def foo(x,y): ---按位置定义的形参，必须一一对应， 不能多，也不能少，
# print(x)
# print(y)
#
# # foo(y=10,x=1)
# foo(y=10,x=1) #关键字参数可以不用像位置实参一样与形参一一对应，指名道姓地传值
6.
把形参固定，研究实参的变化
# foo(1,10)
# foo(x=1,y=10)
# foo(1,y=10)
# foo(y=10,1) #报错，位置实参在前面
# foo(x=10,1) #报错，
# foo(1,x=10,y=20) #实参x重复赋值，
# def foo(x,y,z):
# print(x)
# print(y)
# print(z)
# # foo(1,z=20,10) #关键字在前，报错
# foo(1,y=2,z=10)
#注意的问题一：位置实参必须在关键字实参的前面
#注意的问题二：实参的形式既可以用位置实参又可以是关键字实参，但是一个形参不能重复传值
7.默认参数 --形参
在定义函数阶段，就给形参传值，
#默认参数：在定义函数阶段，就已经为形参赋值,定义阶段有值，调用阶段可以不用传值
# def func(x,y=10):
# print(x)
# print(y)
#形参的应用：值经常变化的需要定义成位置形参，
# 值大多数情况下都一样，需要定义成默认参数
def register(name,age,sex='male'): #定义注册函数 ，性别可以是默认参数
print(name,age,sex)
register('alex',1000)
register('wupeiqi',9000)
register('yuanhao',10000)
register('王铁蛋',10000,'female')
结果
alex 1000 male
wupeiqi 9000 male
yuanhao 10000 male
王铁蛋 10000 female
#默认参数需要注意的问题一：必须放在位置形参后面
#默认参数需要注意的问题二：默认参数通常要定义成不可变类型
#默认参数需要注意的问题三：默认参数只在定义阶段被赋值一次
# x=10
# def func(name,age=x):
# print(name)
# print(age)
# x=20 #已经赋值， 在这里再定义没有意义
#
# func('egon')
# def func(name,age=10,sex='male',hobby=['play1','play2']):
# print(name)
# print(age)
# print(hobby)
#
# func('egon')
-----------------------------------------------------------------------------------------
8.可变长参数
#可变长参数：可变长指的是实参的个数不固定
#按位置定义的可变长度的实参：* ----把按位置定义的多出来的参数保存下来
#按关键字定义的可变长度的实参：** --- 以字典的形式保存下来
#
# 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)
# 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) --*把后面的数字全部拆开，拆成位置参数，
# def func(x,y,z):
# print(x,y,z)
#
# # func(1,*(2,3)) #func(1,2,3) ---拆开成位置参数
# func(*(2,3)) #func(2,3)
#
# def func(x,y=2,z=1):
# print(x,y,z)
#
#
# func(*('a','b','c')) #func('a','b','c')
kwargs
# 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)
# 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,**{'a':1,'b':3,'z':3}) #func(1,y=2,z=3,b=3,a=1)
# def func(x,y=1,z=1):
# print(x,y,z)
#
# func(**{'y':2,'x':1,'z':3}) # 加 ** 代表拆开关键字，与装饰器有关
# def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
# print(args)
# print(kwargs)
#
#
# wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)
#
# def index(name,group):
# print('welcome %s to index page，group is: %s' %(name,group))
#
# def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
# # print(args) #args=(1,2,3)
# # print(kwargs) #kwargs={'x':1,'y':2,'z':3}
# index(*args,**kwargs) #index(*(1,2,3),**{'x':1,'y':2,'z':3}) #index(1,2,3,z=3,y=2,x=1)
#
# wrapper(name='egon',group='group1')
结果
8.命名关键字
命名关键字参数:定义在*后的形参，这类形参，必须被传值，
而且要求实参必须是以关键字的形式来传值
# 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()
# def register(*args,name='egon',age): 默认参数一定在位置参数后面，所以name='egon ,
就不是默认参数，两个都不是位置参数，也不是默认参数，
是命名关键字参数
# print(args)
# print(name)
# print(age)
#
# # register(name='egon',age=18)
# register(1,2,2,3,age=10)
#
# def register(name,age,*,group,**kwargs):
# print(name)
# print(age)
# print(kwargs)
#
#
# # register('egon',18)
# register('egon1',18,hobby='paly1',group='group1')
# def func(x,y=1,*args,z,**kwargs):
# print(x)
# print(y)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,z=10,a=1,b=2)
#
# def func(x,*args,z=1,**kwargs):
# print(x)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,a=1,b=2,c=3)
参数顺序
#形参：位置形参，默认参数，*args，命名关键字参数，**kwargs可变长关键字参数（）
关于函数的形参与实参的对应
1 . *args , 代表取前面的参数把对应的取完，*args取走后面所有的，*是为后面的都是位置参数，
def func(x,y,*args):
print(x,y,args)
func(1,2,3,4,5)--------------1 2 (3, 4, 5) ，args得到是元组形式的参数
2.
def register(*args,name,age) :
print(name)
print(age)
register(age=19,name='egon')
结果
egon
19
----------------------------------------------------------------------------------------------
2. **kwargs
def func(x,y,**kwargs):
print(x,y,kwargs)
func(1,2,z=3,a=4,b=5) ------1 2 {'z': 3, 'a': 4, 'b': 5} 得到元组的形式的参数
-----------------------------------------------------------------------------------------------
4.命名关键字参数
def func(**kwargs) :
print(kwargs)
if 'name' in kwargs :
print(kwargs['name'])
if 'age' in kwargs :
print(kwargs['age'])
func(name='egon',age=18)
结果
{'name': 'egon', 'age': 18} ------得到字典形式，
egon
18
------------------------------------------------------------------------------------------------------
二、名称空间 与作用域
#名字空间：存放名字与值的绑定关系
#名称空间分为三种
#内置名称空间：python解释器自带的名字，python解释器启动就会生成
#全局名称空间：文件级别定义的名字都会存放与全局名称空间，执行python文件时会产生
# x=1
# def func():
# pass
#
# class Foo:
# pass
#
# import os
#
# if 1 > 2 :
# y=3
#局部名称空间:定义在函数内部的名字，局部名称空间只有在调用函数时才会生效，函数调用结束则失效
# def func(x,y): #x=1,y=2
# z=3
# func(1,2)
#三者的加载顺序：内置名称空间->全局名称空间->局部名称空间
#取值：局部名称空间->全局名称空间->内置名称空间
# # max=10
# def func(): #x=1
# # max=20
# print(max)
#
#
# func()
# max=10
#
# def func(): #x=1
# max=20
# # print(max)
# func()
#
#
# print(max)
#
# # x=0
# def f1():
# # x=1
# def f2():
# # x=2
# def f3():
# # x=3
# print(x)
# f3()
# f2()
#
# f1()
#作用域：作用范围
#全局作用域：内置名称空间与全局名称空间的名字属于全局范围，
# 在整个文件的任意位置都能被引用，全局有效
#局部作用域：局部名称空间的名字属于局部范围，
#只在函数内部可以被引用，局部有效
# x=1
# def foo():
# def f2():
# print(x)
# f2()
# def bar():
# print(x)
#
# foo()
# bar()
# def f1():
# x=1
# def f2(): #f2=value
# # x=2
# print(x)
# f2()
# f1()
x=1
def func():
x=2
def f1():pass
# print(dir(globals()['__builtins__'])) #全局作用域name
# print(locals()) #局部作用域name
func()
print(globals() is locals())
#局部作用域----->全局作用域
-------------------------------------------------------------------------------
三 、函数对象
#函数是第一类对象： 指的是函数可以被当做数据传递
def func():
print('from func')
可被引用
f=func
可以当做函数的参数
def func():
print('from func')
def foo(x):
print(x)
x()
foo(func)
可以当做函数的返回值
def foo():
print('from foo')
def bar():
return foo
f=bar()
print(f)
print(foo)
x=0
def f1():
x=1
def f2():
# x=2
print(x)
return f2
f=f1()
# print(f)
f()
可以当做容器类型的元素
def select():
print('select function')
func_dic={
'select':select,
}
# print(func_dic['select'])
func_dic['select']()
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('无效的命令')