##注册
username=input('username:').strip()
pwd=input('password:').strip()
with open('text','a',encoding='utf8')as fa:
fa.write(f'{username}:{pwd}
')
fa.flush()
##登陆
inp_username=input('username: ').strip()
inp_pwd=input('password:').strip()
with open('text','rt',encoding='utf8')as fr:
for user_info in fr:
user_info=user_info.strip('
')
user_info_list=user_info.split(':')
if inp_username==user_info_list[0] and inp_pwd==user_info_list[1]:
print('登陆成功')
break
else:
print('登陆失败')
定义函数
def 函数名(param1,param2....)
'''
函数功能的描述信息
：param1:描述
：param2：描述
：return：返回值
'''
code 1
code 2
code 3
return 返回值
调用函数
函数名(param1,param2....)
##注册功能函数
def register():
'''注册功能'''
username=input('username:').strip()
pwd=input('password:').strip()
with open('text','a',encoding='utf8')as fa:
fa.write(f'{username}:{pwd}
')
fa.flush()
register()
函数调用阶段
def bar():
print('from bar')
def foo():
print('from foo')
bar()
foo()
def foo():
print('from foo')
bar()
def bar():
print('from bar')
foo()
形参和实参
1、形参
def func(x,y):
print(x)
print(y)
2、实参
在函数调用阶段括号内传入的参数，称之为实际参数，简称实参，本质就是变量的值
func(1,2)
位置参数
在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参
关键字实参
在调用函数时，按照key=value的形式为指定的参数传值，称之为关键字实参
特点:可以打破位置的限制，但仍能为指定的形参赋值
注意：
1、可以混用位置实参和关键字实参，但是位置实参必须在关键字实参的左边
2、可以混用位置实参和关键字实参，但不能对一个形参重复赋值
func(x,y=2)
func(y=2,x)
func(x,x=1)
默认形参
在定义阶段，就已经赋值
def func(x,y=10):
print(x)
print(y)
func(2)
特点：在定义阶段就已经被赋值，意味着调用时可以不用为其赋值
注意：
1、位置形参必须放在默认形参的左边
2、默认形参的值只在定义阶段赋值一次，也就是说默认参数的值在函数定义阶段就已经固定了
m = 10
def foo(x=m):
print(x)
m = 111
foo() # 10
1、默认参数的值通常应该是不可变类型
# 演示形参是可变类型
def register(name, hobby, hobby_list=[]):
hobby_list.append(hobby)
print(f"{name} prefer {hobby}'")
print(f"{name} prefer {hobby_list}")
register('nick', 'read')
register('tank', 'zuipao')
register('jason', 'piao')
总结
参数的应用：取决于个人习惯
形参的应用:
1、大多数情况的调用值一样，就应该将该参数定义为位置形参
2、大多数情况的调用值一样，就应该将参数定义成默认形参
可变长形参
可变长参数：指的是在调用函数时，传入的参数个数可以不固定
调用函数时，传值的方式无非两种，一种是位置实参，另外一种是关键字实参，因此形参也必须有两种解决方法，以此来分别接收溢出的位置实参（*）与关键字实参（**）
可变长形参之*
def sum_self(*args):
res=0
for num in args:
res+=num
return res
res=sum_self(1,2,3,4)
print(res) ##10
可变长实参之*
实参中的，会将后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带的，它就是位置实参，应该马上打散成位置实参去看
def func(x,y,z,*args):
print(x,y,z,args)
func(1,*(1,2),3,4)
##1 1 2 (3,4)
可变长形参之**
形参中的**会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给 **后的参数。需要注意的是： *后的参数名约定俗成为kwargs。
def func(**kwargw):
print(kwargw)
func(a=5)
#{'a':5}
可变长实参之**
def func(x,y,z,**kwargs):
print(x,y,z,kwargs)
func(1,3,4.**('a':1,'b':2))
##1 3 4 {'a':1,'b':2}
可变长参数应用
def index(name, age, sex):
print(f"name: {name}, age: {age}, sex: {sex}")
def wrapper(*args, **kwargs):
print(f"args: {args}")
print(f"kwargs: {kwargs}")
index(*args, **kwargs)
wrapper(name='nick', sex='male', age=19)
'''
args: ()
kwargs: {'name': 'nick', 'sex': 'male', 'age': 19}
name: nick, age: 19, sex: male
'''
命名关键字形参
现在有一个需求：函数的使用者必须按照关键字实参传
def register(x, y, **kwargs):
if 'name' not in kwargs or 'age' not in kwargs:
print('用户名和年龄必须使用关键字的形式传值')
return
print(kwargs['name'])
print(kwargs['age'])
register(1, 2, name='nick', age=19)
##nick
##19
命名关键字形参：在函数定义阶段，*后面的参数都是命名关键字
特点：在传值时，必须按照key=value的方法传值，并且key必须命名关键字参数的指定的参数名
def register(x, y, *, name, gender='male', age):
print(x)
print(age)
register(1, 2, x='nick', age=19)
# TypeError: register() got multiple values for argument 'x'