一、作业讲解
注册功能升级：
#1、拿到用户输入的合法的信息：用户名、密码、余额
db_path='db.txt'
def get_uname():
while True:
uname=input('用户名>>：').strip()
if not uname.isalpha():
print(' 33[45m用户名必须为英文字母... 33[0m')
continue
with open(r'%s' %db_path,'r',encoding='utf-8') as f:
for line in f:
uinfo=line.strip('
').split(',')
if uname == uinfo[0]:
print(' 33[45m用户名已存在... 33[0m')
break
else:
return uname
# uname=get_uname()
# print(uname,type(uname),uname.isalpha())
def get_pwd():
while True:
pwd1=input('请输入密码>>: ').strip()
pwd2=input('再次输入密码>>: ').strip()
if pwd1 == pwd2:
return pwd1
else:
print(' 33[45m两次输入的密码不一致，请重新输入... 33[0m')
# pwd=get_pwd()
def get_bal():
while True:
bal=input('请输入余额: ').strip()
if bal.isdigit():
# bal=int(bal)
return bal
else:
print(' 33[45m钱必须是数字，傻叉... 33[0m')
# bal=get_bal()
#2、写入文件
def file_hanle(uname,pwd,bal):
with open(r'%s' %db_path,'a',encoding='utf-8') as f:
f.write('%s,%s,%s
' %(uname,pwd,bal))
# file_hanle('egon','123','300','C:a
db.txt')
# file_hanle('alex','123','300',)
# 注册功能
def register():
uname=get_uname() #拿到合法的用户名
pwd=get_pwd() #拿到合法的密码
bal=get_bal() #拿到合法的余额
file_hanle(uname,pwd,bal) #写入文件
# register()
转账功能
db_path='db.txt'
#1、源账户减钱
def cal_mon(src_user,money):
pass
#2、目标账户加钱
def add_mon(dst_user,money):
pass
def transfer(src_user,dst_user,money):
cal_mon(src_user,money)
add_mon(dst_user,money)
transfer('egon','alex',300)
二、补充知识
1. *的应用场景
def sum2(*args): #args=(1,2,3) ##求和
res=0
for num in args:
res+=num
return res
print(sum2(1,2,3,4,5,6,7))
2. **的应用场景
def auth(name,pwd,**kwargs): ##考虑扩展性
print(name)
print(pwd)
print(kwargs)
auth(name='egon',pwd='123',group='group1')
3. *args 和 **kwargs最重要的应用
def index(name):
print('welecome %s to index page' % name)
def wrapper(*args, **kwargs):
index(*args, **kwargs) # index(1,2,name='egon')
wrapper(1, 2, name='egon')
4. 引用顺序及常规调用
def foo(x,y=1,*args,z,**kwargs): ## *号后面为命名关键字参数， 注意顺序
pass
def foo(x,*args,**kwargs): ##两种常用的使用方式
pass
def foo(x,y=1): ##两种常用的使用方式
pass
三、命名关键字参数
print(help(函数名)) e.g print(help(foo)) , 查看函数
def foo(x,y,*,z):
print(x,y,z)
命名关键字参数：在*后面参数都是命名关键字参数（格式）
特点：
1 必须被传值
1 约束函数的调用者必须按照key=value的形式传值
2 约束函数的调用者必须用我们指定的key名
复杂的写法：
def auth(*args,**kwargs):
"""
使用方式auth(name="egon",pwd="123")
:param args:
:param kwargs:
:return:
"""
# print(args,kwargs)
if len(args) !=0:
print('必须用关键字的形式传参')
return
if 'name' not in kwargs:
print('必须用指定的key名name')
return
if 'pwd' not in kwargs:
print('必须用指定的key名pwd')
return
name=kwargs['name']
pwd=kwargs['pwd']
print(name,pwd)
四、函数嵌套
1、 函数的嵌套调用：在函数内又调用了其他函数
def max2(x,y):
if x > y:
return x
else:
return y
def max3(x,y,z):
res1=max2(x,y)
res2=max2(res1,z)
return res2
print(max3(11,199,2))
2、 函数的嵌套定义：在函数内又定义其他函数
def func1():
print('from func1')
def func2(): #func2=内存地址
print('from func2')
print(func2) #<function func1.<locals>.func2 at 0x0000024907A098C8>
func2()
func1()
def f1():
print('f1')
def f2():
print('f2')
def f3():
print('f3')
f3()
f2()
f1()
五、名称空间与作用域
1、 名称空间：存放名字与值绑定关系的地方
2、 名称空间分为三类
a. 内置名称空间：存放python解释器自带的名字，在解释器启动时就生效，解释器关闭则实效
b. 全局名称空间：文件级别的名字，在执行文件的时候生效，在文件结束或者文件执行期间被删除则失效（del func）（不是内置，局部名称空间（函数里的））
c. 局部名称空间：存放函数内定义的名字（函数的参数以及函数内的名字都存放与局部名称空间），在函数调用时临时生效，函数结束则实效
加载顺序： 内置名称空间-》全局名称空间-》局部名称空间
查找名字： 局部名称空间-》全局名称空间-》内置名称空间
3. 作用域
全局作用域：包含的是内置名称空间与全局名称空间的名字
特点： 在任何位置都能够访问的到；该范围内的名字会伴随程序整个生命周期
局部作用域：包含的是局部名称空间的名字
特点：只能在函数内使用；调用函数时生效，调用结束失效
六、函数对象
函数在python中时第一类对象
1. 可以被引用
def func():
print('from func')
f=func
2. 可以当作参数传入
def bar(x):
print(x)
x()
bar(func)
3. 可以当作函数的返回值
def bar(x): # x=func
return x #return func
res=bar(func) #res=func
# print(res)
res()
4. 可以当作容器类型的元素
def auth():
print('登陆。。。。。')
def reigster():
print('注册。。。。。')
def search():
print('查看。。。。')
def transfer():
print('转账。。。。')
def pay():
print('支付。。。。')
dic={
'1':auth,
'2':reigster,
'3':search,
'4':transfer,
'5':pay
}
# print(dic)
# dic['2']()
def interactive():
while True:
print("""
1 认证
2 注册
3 查看
4 转账
5 支付
""")
choice=input('>>: ').strip()
if choice in dic:
dic[choice]()
else:
print('非法操作')
interactive()
七、闭包函数
闭：指的是定义在函数内部的函数
作用域关系：在函数定义阶段就规定死了，与调用位置无关
def outter():
x=2
def inner():
x=1
print('from inner',x)
return inner
f=outter() #f=inner
def foo():
x=1111
f()
foo()
##以上结果返回1；若x=1被注释，返回2；若x=2亦被注释，报错，x=1111不会被引用，因为它在foo的局部里。
闭合函数：
定义在函数内部的函数；并且该函数包含对外部函数作用域中名字的引用，该函数就成为闭包函数
def outter():
name='egon'
def inner():
print('my name is %s' %name)
return inner
f=outter()
为函数体传值的方式（了解）
方式一：将值以参数的形式传入
import requests
def get(url):
response=requests.get(url)
if response.status_code == 200:
print(response.text)
get('https://www.baidu.com')
方式二：闭包函数
import requests
import time
def outter(url): #url='https://www.baidu.com'
# url='https://www.baidu.com'
def get():
response=requests.get(url)
if response.status_code == 200:
print(response.text)
return get
baidu=outter('https://www.baidu.com')
python=outter('https://www.python.org')
baidu()
print('=====================>')
time.sleep(3)
baidu()