函数

1、 函数的概念

a.函数所解决的问题：

复杂度增大、组织结构不清晰、可读性差、代码冗余、可扩展性差

函数就是具备某一种功能的物件

实现准备工具的过程称为函数的定义

遇到特定的场景拿来就用称为函数的调用

b.函数的分类:

内置函数

自定义函数

2、函数的使用：

1 先定义

2 再调用

a.函数的定义语法：

def  函数名(arg1,arg2,arg3):

“注释”

函数体

return   返回值

注意：

函数名一般是动词

b. retrun的使用：

return 返回值没有类型限制

在函数内部可以有多个return，但只能执行一次，函数就结束调用，并且会把return后的值作为函数执行的结果返回

没有return：返回None，等同于return None

return 一个值：返回该值

return 多个值：返回多个值组成的一个元组

c.定义的三种形式：

无参：应用场景仅仅只是执行一些操作，比如与用户交互、打印等

有参：需要根据外部传进来的参数，才能执行相应的逻辑操作，比如统计长度，求最大值

空函数：设计代码结构

3、函数的调用：

函数调用的三种形式：

a.语句形式

b.表达式形式

c.当做另外一个函数的参数

def my_max(x,y):if x > y:return xelse:return ymy_max(1,2) #语句形式res=my_max(1,2)*10 #表达式形式# res1=my_max(1,2)     #如果不使用第三种形式要写这两行
# res2=my_max(res1,3)res2=my_max(my_max(1,2),3) #函数调用可以当做另外一个函数的参数
print(res2)

练习：

#定义阶段
def foo():print('from foo')bar()
# print(foo)
def bar():print('from bar')#调用阶段
foo()

注意：

函数在定义阶段只检测语法，不执行代码

4、函数参数

a.参数的形式

1 形参

2 实参

#形参：在定义函数时，括号内的参数成为形参
#特点：形参就是变量名
# def foo(x,y): #x=1,y=2
#     print(x)
#     print(y)#实参：在调用函数时，括号内的参数成为实参
#特点：实参就是变量值
# foo(1,2)#在调用阶段实参（变量值）才会绑定形参（变量名）
#调用结束后，解除绑定

b.参数的分类：

1 位置参数：按照从左到右的顺序依次定义的参数

位置形参：必须被传值，并且多一个不行，少一个也不行

位置实参：与形参按照位置一一对应

位置参数：按照从左到右的顺序依次定义的参数位置形参：必须被传值，并且多一个不行，少一个也不行位置实参：与形参按照位置一一对应def foo(x,y):print(x)print(y)foo('egon',1,2)

2 关键字实参：指的是按照name=value的形式，指名道姓地给name传值

注意问题：

问题一: 语法规定位置实参必须在关键字实参的前面

问题二: 一定不要对同一个形参传多次值

关键字实参：指的是按照name=value的形式，指名道姓地给name传值
def foo(name,age):print(name)print(age)foo('egon',18)
foo(age=18,name='egon')关键字实参需要注意的问题是：
def foo(name,age,sex):print(name)print(age)print(sex)foo('egon',18,'male')
print('======>')
foo(sex='male',age=18,name='egon')
foo('egon',sex='male',age=18)问题一:语法规定位置实参必须在关键字实参的前面
foo('egon',sex='male',age=18)问题二:一定不要对同一个形参传多次值
foo('egon',sex='male',age=18,name='egon1')foo('male',age=18,name='egon1')

3 默认形参：在定义阶段，就已经为形参赋值，意味在调用阶段可以不用传值

默认参数需要注意的问题：
问题一：默认参数必须放在位置参数之后
问题二：默认参数只在定义阶段赋值一次，而且仅一次
问题三：默认参数的值应该定义成不可变类型

默认形参：在定义阶段，就已经为形参赋值，意味在调用阶段可以不用传值
def foo(x,y=1111111):print(x)print(y)foo(1,'a')def register(name,age,sex='male'):print(name,age,sex)register('asb',73)
register('wsb',38)
register('ysb',84)
register('yaya',28,'female')默认参数需要注意的问题
问题一:默认参数必须放在位置参数之后
def foo(y=1,x):print(x,y)问题二：默认参数只在定义阶段赋值一次，而且仅一次
x=100
def foo(a,b=x):print(a,b)x=111111111111111111111111111111
foo('egon')问题三：默认参数的值应该定义成不可变类型

4 可变长参数：指的是实参的个数不固定

形参必须要两种机制来分别处理实参：

按照位置定义的实参溢出的情况：*

跟按照关键字定义的实参溢出的情况：**

处理位置实参：*会把溢出的位置实参保存成元组

def foo(x,y,*args): #nums=(3,4,5,6,7)print(x)print(y)print(args)foo(1,2,3,4,5,6,7) #*
foo(1,2) #*输出结果：
1
2
(3, 4, 5, 6, 7)
1
2
()

处理关键字实参：**会把溢出的关键字实参保存成字典

def foo(x,y,**kwargs): #kwargs={'z':3,'b':2,'a':1}print(x)print(y)print(kwargs)
foo(1,2,z=3,a=1,b=2) #**输出结果：
1
2
{'z': 3, 'a': 1, 'b': 2}

*、**结合使用

def wrapper(*args,**kwargs): #args=(1,2,3) kwargs={'a':1,'b':2}print(args)print(kwargs)
wrapper(1,2,3,a=1,b=2)

命名关键字参数：在*后面定义的形参称为命名关键字参数，必须是以关键字实参的形式传值

def foo(name,age,*args,sex='male',group):print(name)print(age)print(args)print(sex)print(group)foo('alex',18,19,20,300,group='group1')

5、函数对象

函数是第一类的对象：指的是函数可以被当做数据传递

a.被赋值

b.可以当做参数传入

c.可以当做函数的返回

d.可以当做容器类型的元素

def foo():print('from foo')
f=foo          #把函数名赋值给变量
print(f)
f()            #使用变量名可以调用函数def wrapper(func):# print(func)func()
wrapper(foo)          #把函数名foo当做参数传递给funcdef wrapper(func):   #把函数名foo当做参数传递给func，func当做return         return func               #的返回值
res=wrapper(foo)
print(res)cmd_dic={'func':foo            #把函数名以value的形式传入字典中
}print(cmd_dic)cmd_dic['func']()

函数练习：

1、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批量修改操作
filename=input('请输入你要修改的文件名：')
old=input('请输入你要修改的内容：')
new=input('请输入新内容：')
def modify(filename,old,new):import oswith open(filename,'r',encoding='utf-8') as read_f,\open('.bak.swap','w',encoding='utf-8') as write_f:for line in read_f:if old in line:line=line.replace(old,new)write_f.write(line)os.remove(filename)os.rename('.bak.swap',filename)modify(filename,old,new)2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def calculation(str):res={'nums': 0,'string': 0,'space': 0,'other': 0}for s in str:if s.isdigit():res['nums']+=1if s.isalpha():res['string']+=1if s.isspace():res['space']+=1else:res['other']+=1return res
str=input('请输入要判断的字符串：')
res=calculation(str)
print(res)3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5
def judge(object):if len(object) >5:return object
object=input('请输入字符串、列表或元组：')
judge(object)4、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者
def check(str):if len(str) >2:str=str[0:2]return str
str=input('请输入元素：')
print(check(str))5、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者
def check_index(objects):return objects[::2]
objects=input('请输入列表或元组：')
print(check_index(objects))6、写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者
dic = {'k1':'v1v1','k2':[11,22,33,44]}
def check_dic(dic):d={}for key,value in dic.items():if len(value) > 2:d[key]=value[0:2]return dprint(check_dic(dic))