1、什么是函数?
在程序中,函数就是具备某一功能的工具,事先将工具准备好即函数的定义,遇到应用场景拿来就用即函数的调用,所以务必记住:#函数的使用必须遵循先定义,后调用的原则
2、为何要用函数,不用函数问题是:
1、程序冗长
2 程序的扩展性差
3 程序的可读性差
3 、如何用函数:
函数的使用必须遵循先定义,后调用的原则
如何定义函数:
def 函数名(参数1,参数2,...): ''' 函数功能的描述信息 :param 参数1: 描述 :param 参数2: 描述 :return: 返回值 ''' 代码1 代码2 代码3 ... return 返回值 #可有返回值可没有返回值,遇到return函数执行结束
1 def register(): 2 while True: 3 uname=input('username>>:').strip() 4 if uname.isalpha(): 5 break 6 else: 7 print('用户名必须由字母组成傻叉') 8 while True: 9 pwd1=input('密码>>: ').strip() 10 pwd2=input('重复输入密码>>: ').strip() 11 if pwd1 == pwd2: 12 break 13 else: 14 print('两次输入的密码不一致,眼瞎吗') 15 with open('db.txt','at',encoding='utf-8') as f: 16 f.write('%s:%s\n' %(uname,pwd1)) 17 f.flush() #立即刷入文件内容 18 19 def auth(): 20 认证功能 21 inp_uname=input('请输入你的账号:').strip() 22 inp_pwd=input('请输入你的密码:').strip() 23 with open('db.txt','rt',encoding='utf-8') as f: 24 for line in f: 25 info=line.strip('\n').split(':') 26 if inp_uname == info[0] and inp_pwd == info[1]: 27 print('login successfull') 28 break 29 else: 30 print('账号或密码错误')
(1)函数定义阶段:只检测函数体的语法,不执行函数体代码
def func():
print('1111')
print('222')
print('333')
func()
错误调用步骤
1 (1) 2 def foo(): 3 print('from foo') 4 bar() 5 def bar(): 6 print('from bar') 7 foo() 8 (2) 9 def bar(): 10 print('from bar') 11 12 def foo(): 13 print('from foo') 14 bar() 15 16 foo() 17 (3)#错误代码 18 def foo(): 19 print('from foo') 20 bar() 21 foo() 22 def bar(): 23 print('from bar')
二、函数的参数
(1)无参函数:
在函数定义阶段括号内没有参数,称为无参函数
注意:定义时无参,意味着调用时也无需传入参数
应用:
如果函数体代码逻辑不需要依赖外部传入的值,必须定义无参函数
def func():
print('hello world')
func()
(2)有参函数
在函数定义阶段括号内有参数,称为有参函数
注意:定义时有参,意味着调用时也必须传入参数
应用:
如果函数体代码逻辑需要依赖外部传入的值,必须定义成有参函数
1 def sum2(x,y): 2 x=10 3 y=20 4 res=x+y 5 print(res) 6 sum2(10,20) 7 sum2(30,40) 8 9 def check_user(): 10 while True: 11 uname=input('username>>:').strip() 12 if uname.isalpha(): 13 return uname 14 break 15 else: 16 print('用户名必须由字母组成傻叉') 17 18 def check_pwd(): 19 while True: 20 pwd1=input('密码>>: ').strip() 21 pwd2=input('重复输入密码>>: ').strip() 22 if pwd1 == pwd2: 23 return pwd1 24 else: 25 print('两次输入的密码不一致,眼瞎吗') 26 27 def db_hanle(uname,pwd1): 28 with open('db.txt','at',encoding='utf-8') as f: 29 f.write('%s:%s\n' %(uname,pwd1)) 30 f.flush() 31 32 def register(): 33 #检测用户名是否合法 34 x=check_user() x='EGON' 35 #检测密码是否合法 36 y=check_pwd() y='123' 37 #写入数据文件 38 db_hanle(合法的用户名,合法的密码) 39 db_hanle(x,y) 40 register()
(3)空函数(主要用来前期搭建逻辑框架思维)
1 def func(): 2 pass 3 def check_user(): 4 pass 5 def check_pwd(): 6 pass 7 def write_db(x,y): 8 pass
三、函数的返回值
1、什么是返回值?
返回值是一个函数运行结束后的处理结果
2、为什么要有返回值?
如果我们需要在程序中拿到函数的处理结果做进一步的处理,则需要函数必须有返回值
3、函数的返回值的应用
函数的返回值用return去定义
格式为:
return 值
注意:
1、return是一个函数结束的标志,函数内可以有多个return,但只要执行一次,整个函数就会结束运行
2、return 的返回值无类型限制,即可以是任意数据类型
3、return 的返回值无个数限制,即可以用逗号分隔开多个任意类型的值
0个:返回None,ps:不写return默认会在函数的最后一行添加return None
1个:返回的值就是该值本身
多个:返回值是元组
四、函数的调用
1 什么是调用函数?
函数名(...)即调用函数,会执行函数体代码,直到碰到return结束或者一直运行完毕所有代码
2 为何要调用函数?
调用函数的目的就是为了调用用函数的功能
总的分类:
1、形参:在函数定义阶段括号内定义的参数,称之为形式参数,简称形参,本质就是变量名
2、实参:在函数调用阶段括号内传入的值,称之为实际参数,简称实参,本质就是变量的值
详细的分类:
一、位置参数:
位置形参:在函数定义阶段,按照从左到右的顺序依次定义的形参,称之为位置形参
特点:但凡是按照位置定义的形参,都必须被传值,多一个不行,少一个也不行
def foo(x,y): print('x:',x)
位置实参:在函数调用阶段,按照从左到右的顺序依次定义的实参,称之为位置实参
特点:按照位置为对应的形参依次传值
def foo(x,y):
foo(1,2)
foo(2,1)
二、关键字实参:在调用函数时,按照key=value的形式为指定的参数传值,称为关键字实参
特点:可以打破位置的限制,但仍能为指定的形参赋值
def foo(x,y): foo(1,y=2,x=10)
三:默认参数:在函数定义阶段,就已经为形参赋值,该形参称为默认形参,特点:在定义阶段就已经被赋值,意味着在调用可以不用为其赋值
def foo(x,y=10): print('x:',x) print('y:',y) foo(1) #不赋值 默认为10 foo(1,3) #赋值为新的数值3
注意:
1、位置形参必须放到默认形参的前面,否则报语法错误
2、默认参数的值只在定义阶段赋值一次,即默认参数的值在函数定义阶段就已经固定死了
3、默认参数的值通常应该定义不可变类型
1 1(错误事例) 2 def register(name,hobby,hobbies=[]): 3 hobbies.append(hobby) 4 print('%s的爱好' %name,end=':') 5 print(hobbies) 6 7 register('isetan','play') 8 register('axxx','piao') 9 register('lxx','烫头') 10 11 2(正确方法) 12 13 def register(name,hobby,hobbies=None): 14 if hobbies is None: 15 hobbies=[] 16 hobbies.append(hobby) 17 print('%s的爱好' %name,end=':') 18 print(hobbies) 19 20 register('isetan','play') 21 register('axxx','piao') 22 register('lxx','烫头')
四:可变长参数:指的是在调用函数时,传入的参数个数可以不固定,而调用函数时,传值的方式无非两种,一种位置实参,另一种时关键字实参,所以对应着,形参也必须有两种解决方案,来分别接收溢出的位置实参(*)与关键字实参(**)
1、形参中某个参数带*形参中的*会将溢出的位置实参全部接收,然后存储元组的形式,然后把元组赋值给*后的变量名
1 def foo(x,y,*z): x=1,y=2,z=(3,4,5,6,7) 2 print(x) 3 print(y) 4 print(z) 5 foo(1,2,3,4,5,6,7) 6 7 应用 8 def my_sum(*nums): 9 res=0 10 for num in nums: 11 res+=num 12 return res 13 print(my_sum(1,2,3,4,5))
2、实参中的参数也可以带*实参中带*,*会将该参数的值循环取出,打散成位置实参,ps:以后但凡碰到实参中带*的,它就是位置实参,应该立马打散成位置实参去看
1 def foo(x,y,z): 2 print(x,y,z) 3 4 foo(1,*[2,3]) foo(1,2,3) 5 foo(1,*'he') foo(1,'h','e') 6 foo(1,*(2,3,4)) foo(1,2,3,4) 7 8 def foo(x,y,z,*args): 9 print(x) 10 print(y) 11 print(z) 12 print(args) 13 14 foo(1,2,3,4,5,6,7,*[8,9,10,11]) foo(1,2,3,4,5,6,7,8,9,10,11) 15 注意:约定俗成形参中的*变量名的写法都是:*args
3、形参中某个参数带**--形参中的**会将溢出的关键字实参全部接收,然后存储字典的形式,然后把字典赋值给**后的变量名
1 def foo(x,y,**z): x=1,y=2,z={'c':5,'b':4,'a':3} 2 print(x) 3 print(y) 4 print(z) 5 foo(1,2,a=3,b=4,c=5)
4、实参中的参数也可以带**,该参数必须是字典--实参中带**,**会将该参数的值循环取出,打散成关键字实参,ps:以后但凡碰到实参中带**的,它就是关键字实参,应该立马打散成关键字实参去看
1 def foo(x,y,z): 2 print(x) 3 print(y) 4 print(z) 5 6 foo(1,2,**{'a':1,'b':2,'c':3,'z':3}) foo(1,2,c=3,b=2,a=1,z=3) 7 foo(**{'z':3,'x':1,'y':2}) foo(y=2,x=1,z=3)
注意:约定俗成形参中的**变量名的写法都是:**kwargs
1 def index(name,age,sex): 2 print('welecome %s:%s:%s to index page' %(name,age,sex)) 3 4 def wrapper(*args,**kwargs): args=(1,),kwargs={'x': 1, 'y': 2, 'z': 3} 5 index(*args,**kwargs) index(*(1,),**{'x': 1, 'y': 2, 'z': 3}) index(1,x=1,y=2,z=3) 6 7 wrapper(name='isetan',sex='male',age=18)
五 命名关键字形参:在函数定义阶段,*后面的参数都是命名关键字参数(**),特点:在传值时,必须按照key=value的传,并且key必须命名关键字参数指定的参数名
1 (1) 2 def register(x,y,z,**kwargs): kwargs={'b':18,'a':'isetan'} 3 if 'name' not in kwargs or 'age' not in kwargs: 4 print('用户名与年龄必须使用关键字的形式传值') 5 return 6 print(kwargs['name']) 7 print(kwargs['age']) 8 register(1,2,3,a='isetan',b=18) 9 (2) 10 def register(x,y,z,*args,name='isetan',age): 11 print(args) 12 print(name) 13 print(age) 14 register(1,2,3,4,5,6,7,age=18) 15 (3) 16 def foo(x,y=1,*args,z=1,a,b,**kwargs): 17 pass 18 19 foo(1,*[1,2,3],a=1,**{'x':1,'y':2}) foo(1,1,2,3,a=1,y=2,x=1) 20 foo(1,2) 21 foo(x=1,y=2)