一，函数总结1、什么是函数
函数就是具备某一特定功能的工具
2、为什么用函数
减少重复代码
增强程序的扩展性
增强可读性
3、如何用函数
1、函数的使用原则：先定义后调用（*****）
定义阶段：只检测语法不执行代码
调用阶段：执行函数代码
2、定义阶段与调用阶段：
2.1：语法 （*****）
def func(参数1，参数2,...):
"""文档注释"""
code1
code2
code3
return 返回值
2.2 形参与实参 （*****）
形参本质就是变量名
实参本质就是变量的值
形参：
位置形参
def foo(x,y):
pass
默认形参
def foo(x,y=1):
pass
*args
def foo(x,*args):
pass
**kwargs
def foo(x,**kwargs):
pass
实参：
位置实参
foo(1,2,3,4)
关键字实参
foo(x=1,y=2,z=3)
foo(x=1,1) # 错误
foo(1,x=1) #错误
*可迭代的对象
foo(*'hello')
**字典
foo(**{'x'：1，'y':2})
2.3 返回值（*****）
return是函数结束的标志，函数内可以有多个return，但只要执行一次函数就立刻结束
并且把return后的值当作本次调用结果返回
def foo(x,y):
return x+y
res=foo(1,2)
注意:
1、返回值可以是任意类型
2、返回值没有个数限制
函数内没有return：默认返回None
return 值1：返回该值
return 值1，值2，值3：返回（值1，值2，值3）
3、函数对象（*****）
def foo():
pass
函数可以被当作数据去处理
1、引用
f=foo
2、当作参数
print(foo)
3、当作返回值
def bar():
def wrapper()
pass
return wrapper
f=bar()
4、当作容器类类型的元素
def f1():
pass
def f2():
pass
l=[f1,f2]
l[0]()
func_dic={
'f1':f1,
'f2':f2
}
4、函数嵌套（*****）
4.1 函数的嵌套调用
def foo()
bar()
f1()
f2()
foo()
4.2 函数的嵌套定义
def f1():
def f2():
pass
f2()
5、名称空间与作用域（******）
内置名称空间
全局名称空间
局部名称空间
def foo(x,y): #x=1,y=2
pass
foo(1,2)
加载顺序：内置->全局-》局部
查找名字的顺序：从当前位置往上查找
如果当前位置在局部
局部—》全局-》内置
x=1
def outter():
def wrapper():
print(x)
return wrapper
f=outter()
def bar():
x=111111
f()
全局作用域：全局存活，全局有效
内置+全局
局部作用域：临时存活，临时有效
局部
l=[]
n=100
def foo():
l.append(1111)
global n
n=1
def f1():
x=1
def f2():
def f3():
nonlocal x
x=10
globals()
locals()
6、闭包函数(****)
x=1
def outter():
x=10
def wrapper():
print(x)
return wrapper
f=outter()
7、装饰器（****）
def deco(func):
def wrapper(*args,**kwargs):
res=func(*args,**kwargs)
retutrn res
return wrapper
def deco1(x=1,y=2):
def deco(func):
def wrapper(*args,**kwargs):
res=func(*args,**kwargs)
retutrn res
return wrapper
return deco
@deco
def index():
pass
8 迭代器（****）
for
max
min
sorted
filter
map
9 生成器（***）
10 三元表达式、列表推导式，字典生成式，生成器表达式（*****）
res=条件成立的结果 if 条件 else 条件成立的结果
l=[表达式 for i in 可迭代对象 if 条件]
g=(表达式 for i in 可迭代对象 if 条件)
d={k:v for i in 可迭代对象 if 条件}
11 匿名函数（*****）
lambda 参数1,参数2:表达式
max
min
sorted
map
filter
12 内置函数
13 函数递归（****）
'''
两个装饰器的运用
def deco1(func1): #func1=wrapper2
def wrapper1(*args, **kwargs):
print('第一个装饰器')
res1 = func1(*args, **kwargs)
return res1
return wrapper1
def deco2(func2): #func2=最原始的index
def wrapper2(*args, **kwargs):
print('第二个装饰器')
res2 = func2(*args, **kwargs)
return res2
return wrapper2
@deco1 #index=deco1(wrapper2)=wrapper1
@deco2 # index=deco2(index)=wrapper2
def index():
print('from index')
index()
'''
第一个装饰器
第二个装饰器
from index二，面向过程函数
'''
面向过程编程
核心过程二字，过程指的是解决问题的步骤，即先干什么、再干什么、然后干什么...
基于该思想编写程序就好比在设计一条流水线，是一种机械式的思维方式
优点
复杂的问题流程化、进而简单化
缺点
扩展性极差
'''
# 接收用户输入用户名,进行用户名合法性校验，拿到合法的用户名
def check_user():
while True:
name = input('username>>').strip()
if name.isalpha():
return name
else:
print('用户名必须为字母，傻叉')
# 接收用户输入密码,进行密码合法性校验，拿到合法的密码
def check_pwd():
while True:
pwd1=input('password>>: ').strip()
if len(pwd1) < 5:
print('密码的长度至少5位')
continue
pwd2=input('again>>: ').strip()
if pwd1 == pwd2:
return pwd1
else:
print('两次输入的密码不一致')
def check_age():
pass
# pwd=check_pwd()
# print(pwd)
# 将合法的用户名与密码写入文件
def insert(user,pwd,age,path='db.txt'):
with open(path,mode='a',encoding='utf-8') as f:
f.write('%s:%s:%s\n' %(user,pwd,age))
def register():
user=check_user()
pwd=check_pwd()
age=check_age()
insert(user,pwd,age)
print('register successfull')
register()
# 用户功能层
def register():
while True: # 检测用户名
name=input('username>>: ').strip()
#检测用户是否重复，如果重复了则重新输入，否则break
res=check_user_interface(name)
if res:
print('用户存在')
else:
break
while True: # 检测密码
pwd1 = input('pwd1>>: ').strip()
pwd2 = input('pwd2>>: ').strip()
if pwd1 != pwd2:
print('两次输入密码不一致，重新输入')
else:
break
def tell_info():
name=input('>>: ').strip()
info=select(name)
print(info)
# 接口层
def check_user_interface(name):
res = select(name) # res=['egon','123']
if res:
return True
else:
return False
# 数据处理层
def select(name):
with open('db.txt', 'r', encoding='utf-8') as f:
for line in f:
info = line.strip('\n').split(':') #info=['egon','123']
if name == info[0]:
return info
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
