一:函数介绍
1、不用函数会怎么样？什么是函数？
1、组织结构不清晰，可读性差
2、代码冗余
3、管理维护难度极大
4、函数就是事先准备工具的过程
二:函数定义
1、语法
def 函数名（参数一，参数二，.......）：
‘’‘
文档描述
’‘’
代码一
代码二
代码三
return 值
def：定义函数的关键字
函数名：是用来调用函数的，函数名必须能反映函数的功能
文档描述：推荐写上，来增强代码的可读性
代码块：函数的功能实现代码
return：函数的返回值
def print_sym(sym,count): #print_sym=<function print_msg at 0x000001B2A33698C8>
print(sym*count)
函数在定义阶段值检测语法，不执行函数代码
2、定义函数的三种类型
1、有参函数：参数是函数体代码用来接收外部传入值的
def sum(x,y):
z=x+y
print(z)
sum(1,2)
2、无参函数：当函数的代码逻辑不需要函数的调用者掺入值的情况下，就无参
def interactive():
name=input('请输入你的用户名')
password=input('请输入你的密码')
print(name,password)
interactive()
3.空函数：函数体为pass
def auth():
"""
文档描述
"""
pass
三:函数调用
1、函数的使用必须遵循：先定义，后调用的原则
2、调用阶段：根据函数名找到函数的没存地址，然后执行函数体代码
3、函数名加括号就是调用
4、调用函数的三种形式
1、直接调用
def func():
print('钱大佬')
2、返回值调用
def sum(x,y):
z=x+y
return z
res=sum(z)
print(res)
3、运算调用
def sum(x,y):
z=x+y
return z
res=sum(z)+50
print(res)
四:函数的返回值
1、函数值：
return
2、定义：
函数体运行结束后需要有一个返回结果给调用者
3、返回值的三种方式
1.没有return，返回值None
def fun():
pass
res=func()
print(res)
2.return后跟一个值，返回值本身
def func1
return 1
res=func1()
print(res)
3.return可以以逗号分隔，返回多个值，会返回一个元组给调用着
def func2():
return1,2,3,4,[1,2,3]
res=func2()
print(res)
4、return返回值的值是没有类型限制的
return是函数结束的标志，函数可以写多个return，但只执行一个return，
函数就会结束，并把return后的值作为本次调用
函数练习
1、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操作
def alter(x,y):
import os
with open('x.txt.txt','r',encoding='utf-8') as read_f,
open('x.txt.txt.swap','w',encoding='utf-8')as write_f:
for i in read_f:
if x in i:
i=i.replace(x,y)
write_f.write(i)
os.remove('x.txt.txt')
os.rename('x.txt.txt.swap','x.txt.txt')
print('修改成功')
alter('sxx','王5')
2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def number(x):
res = {
'num': 0,
'string': 0,
'space': 0,
'other': 0,
}
for i in x:
if i.isalpha():
res['string']+=1
elif i.isdigit():
res['num']+=1
elif i.isspace():
res['space']+=1
else:
res['other']+=1
return res
n=number('123sadasd...... 家十九大')
print(n)
3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
def length(x):
if len(x)>5:
print('长度大于5')
else:
print('长度小于5')
length('dasdada')
4、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，
并将新内容返回给调用者。
def length(x):
if len(x)>2:
x=x[0:2]
return x
c=[1,2,3,4,5,6]
c=length(c)
print(c)
5、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其
作为新列表返回给调用者。
def odd(x):
c=[]
for i in range(len(x)):
if i%2==1:
c.append(x[i])
return c
n=(1,2,3,4,5,7,8,9,0)
n=odd(n)
print(n)
6、写函数，检查字典的每一个value的长度, 如果大于2，那么仅保留前两个长度的内
容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11, 22, 33, 44]}
def length(x):
for i in x:
if len(x[i])>2:
x[i]=x[i][0:2]
return x
dic=length(dic)
print(dic)
7、编写认证功能函数，注意：后台存储的用户名密码来自于文件
def attestation(c):
l={}
inp_name=input("请输入用户名")
inp_password=input("请输入密码")
with open(r'%s'%c,'r',encoding='utf-8') as f:
for i in f:
data=i.split(',')
print(data)
l.setdefault(data[0])
l[data[0]]=data[1].strip('
')
if inp_name in l and inp_password ==l[inp_name]:
print('用户名密码正确')
else:
print('用户名密码错误')
attestation('w.txt')
8、编写注册功能函数，将用户的信息储存到文件中
def login(x):
inp_name=input("请输入用户名").strip()
inp_paw=input("请输入密码").strip()
inp_sex=input("请输入性别").strip()
inp_age=input("请输入年龄").strip()
with open('%s'%x,'w',encoding='utf-8') as f:
f.write('%s,%s,%s,%s,0'%(inp_name,inp_paw,inp_sex,inp_age))
print('注册成功，跳转登录')
login('w.txt')
9、编写查看用户信息的函数，用户的信息是事先存放于文件中的
def check(c):
l={}
inp_name=input("请输入用户名")
inp_password=input("请输入密码")
with open(r'%s'%c,'r',encoding='utf-8') as f:
for i in f:
data=i.split(',')
l.setdefault(data[0])
l[data[0]]=data[1].strip('
')
if inp_name in l and inp_password ==l[inp_name]:
print(l)
else:
print('用户名密码错误，无法查看')
check('w.txt')
五、参数
1、函数参数有两种分类方式：
1）形参、实参
形参：在定义时，括号内定义的参数，形参就是变量名
实参：在调用时，括号内传入的值，实参就是变量名
2）位置参数、关键字参数、默认参数、可变长参数
2、位置参数
1、定义：位置即顺序，位置参数值的就是按照从左到右的顺序依次定义的参数
2、位置参数：位置形参、位置实参
1）位置形参
定义函数时，按照位置定义的形参，称为位置形参
def foo(x,y,z): #按照顺序 print(x,y,z)
#注意点：在掉用函数时，必须为其传值，而且多一个不行，少一个不行
2）位置实参
按照位置定义的实参，称为位置实参
foo(1,2,3)#按照顺序传值
#注意点：位置实参会与形参一一对应
3、关键字参数
1、定义：在调用函数时，按照key=value的形式定义的实参，
称为关键字参数
2、关键字参数:
相当于指名道姓地为形参传值，以为着不按照顺序定义，
仍然能为指定的参数传值
def foo(x,y,z): print('你好') foo(1,2,z=12) #位置实参可以和关键字参数合用 foo(1,z=12,2) #错误用法,关键字参数必须在为参数后面
foo(1,x=1,y=2,z=12)#错误用法,不能为同意个形参传值
4、默认参数
定义：在定义阶段已经为摸个形参赋值，这种形参就叫默认参数
def register(name,age,sex='male'): print(name,age,sex) def func(y=1,x): #错误,默认函数必须在位置形参后面 pass
注意：默认参数只在定义阶段赋值一次，也就是说默认参数的值在定义阶段就固定死了
m=10#次位传
def foo(x,y=m):
print(x,y)
m='1213'#传不进去，因为已经到了调用阶段
foo(1)
foo(1,11)#最先传
5、可变长参数
1、定义：实参不固定，如何将多于的实参传进去
2、可变长位置参数：
1）可变长位置参数*args：
*将溢出的位置实参全部接收，然后保存为元组
的形式赋值给args
def foo(x,y,z,*args): #args=(4,5,6,7,8)
print(x,y,z)
print(args)
foo(1,2,3,4,5,6,7,8,)
2）可变长关键字参数**kwargs：
*将溢出的关键字实参全部接收，然后保存为字典
的形式赋值给args
def foo(x,y,z,**kwargs): #kwargs={'a':1,'b':2,'c':3}
print(x,y,z)
print(args)
foo(1,2,3,a=1,b=2,c=3)
3、实参中包含*、**
def s(x,y,z):
print(x,y,z)
s(1,*'ds')
#将加星的参打散成一个个元素传入形参
def s(x,y,z):
print(x,y,z)
s(1,**{'y':1,'z':2})
六、函数嵌套
1、定义
在函数中有定义期他函数
def func1():
print('1')
def func2(): #func2=内存地址
print('2')
2、嵌套调用
函数的嵌套调用：在函数内又调用了其他函数
def f1():
print('f1')
def f2():
print('f2')
def f3():
print('f3')
f3()
f2()
f1()
七、名称空间与作用域
1、名称空间
1)内置名称空间：存那python解释器自带的名字，在解释器启动时
就生效，解释器关闭就失效
2)全局名称空间：文件级别的名字，在执行文件的时候生效，在文
件结束时失效
3)局部名称空间：存放在函数内定义的名字(函数的参数以及函数内
的名字都存放于局部名称空间)，函数调用时临时生效，函数结束
是失效
5)名称存储空间优先级：内置名称空间>全局名称空间>局部名称空间
4)名称查找优先级：局部名称空间>全局名称空间>内置名称空间
len='global'
def f1():
# len=1
def f2():
# len=2
print(len)
f2()
f1()
2、作用域
1）全局作用域：包含内置名称空间和全局空间的名字，在任何
位置都能访问到
2）局部作用域：包含的是局部空间的名字，只能在函数内访问
八、函数对象
1、定义：
函数在python中是第一类对象
2.、作用：
1）可以被引用
def bar():
print('from bar')
f=bar
f()
2）可以当做参数传入
def bar():
print('from bar')
def wrapper(func): #func=bar
func() #bar()
wrapper(bar)
3）可以当做函数的返回值
def bar():
print('from bar')
def foo(func):
print('from foo')
f=foo(bar)
f()
4）可以当做容器类型的元素
def get():
print('from get')
def put():
print('from put')
l=[get,put]
l[0]()
九、闭包函数
定义：
在函数内部的函数并且该函数包含对外部函数作用域中名字的引
用，该函数就称为闭包函数
def outter():
name='egon'
def inner():
print('my name is %s' %name)
return inner
f=outter()
