参数

# 形式参数 foo(x,y),x和y就是形式参数，实质是变量名
# 在函数调用阶段时，括号内定义的参数foo(1,2)，1和2是实际参数，实质是变量值
# 函数内部的赋值不会影响外部的赋值

# 例如：
# x=999
#
# def foo(x,y):
#     print(x)
#     print(y)
#
# foo(1,2)
#
# print(x)

# 参数是可变类型与不可变类型的差异：
# 参数是不可变类型,print(x)=1
# def bar(x):
#     print(x)
#     x=3
#
# x=1
# bar(x)
# print(x)
#
# # 参数是可变类型,print(x)=[1, 2, 3, 4],这样容易出错
# # 在这个情况下，不允许函数不要传可变类型
# def bar(x):
#     print(x)
#     x.append(4)
#
# x=[1,2,3]
# bar(x)
# print(x)
#
# # 实参的用法：
# # 1、按位置传值
# foo(1,2)
#
# # 2、按关键字传值
# foo(x=1,y=2)
# foo(y=2,x=1)
#
# # 3、两种混着用
# foo(1,y=2)
# # 不允许,按位置传值要在关键字传值的前面，
# foo(y=2,1)
# # 对一个参数不能重复赋值
# foo(1,x=1,y=2)

# 参数不能传少，也不能传多
# foo(1)
# foo(1,2,3)

# 默认参数
def foo(x,y=1):
    print(x)
    print(y)

foo(1,2)
foo(1)
foo(x=3,y=4)

# 如果不注明用什么编码方式，就用系统默认的
# f=open("a.txt","w")
# f.write("1111 ")
# f.write("11ssss11")
# f.writelines(["1111 ","eee "])
# f.seek(0)
#
# # 只要光标后3个字符
# f.truncate(3)
#
# f.close()
# with open("a.txt") as f,open("b.txt") as f2:
#     pass
#
# f.flush()

# 函数：就是工具
# 1、内置函数print
# 2、自定义函数

'''
##################
alex sb sb
##################
'''
def

# 默认参数要注意的问题：
# 1、默认参数要放在位置参数的后面
# def regsiter_xinyonghu(name,sex="male"):
#     print(name)
#     print(sex)

# 由于x="male"在函数前面，所以sex="male"
x="male"
def reg(sex=x):
    print(sex)

x=None
reg()

# 换个位置，结果就不同
x="male"
x=None
def reg(sex=x):
    print(sex)
reg()

# *args(也可以*a  *b 只是习惯用args)
# 把多余的参数用元组的方式，保存到args这个参数中
# 先写位置参数，再写关键参数，最后写*
# def foo(x,*args):
#     print(x)
#     print(args)
#
# foo(1,2,3,4,5,)

# 求和函数
# def my_sum(*nums):
#     res=0
#     for i in nums:
#         res+=i
#     return res
#
# print(my_sum(1,2,3,4))

# 先写位置参数，(关键参数与*参数不会一起用，容易错）
# def foo(x,y=1,*args):
#     print(x)
#     print(y)
#     print(args)
#
# foo(1,2,3,4,5,6)
#
# # 先写位置参数，如果关键参数与*参数一起用，要这个顺序
# def foo(x,*args,y=1):
#     print(x)
#     print(y)
#     print(args)
#
# foo(1,2,3,4,5,6,y=123)

# 把*放到实参中，如下：*args=(a,b,c,d,...)
# def bar(x,y,z):
#     print(x)
#     print(y)
#     print(z)
#
# bar(*(1,2,3))

## **kwargs:按关键字传值时，会以字典形式传值
# def foo(x,**kwargs):
#     print(x)
#     print(kwargs)
#
# foo(x=1,y=2,z=3,b=4)

# 由于*的本质是按位置传值，所以排在**前面
# def foo(x,*args,**kwargs):
#     print(x)
#     print(args)
#     print(kwargs)
#
# foo(x=1,y=2,z=3)
# foo(1,33,y=2,z=3)

# 从实参角度
# def foo(x,y,z=1):
#     print(x)
#     print(y)
#     print(z)
#
# foo(**{'x':1,'y':2,'z':3})
# foo(**{'x':1,'y':2})
# # x不能换a,否则报错
# foo(**{'a':1,'y':2})

# 输入账号密码
def auth(name,passwd,sex='male'):
    print(name)
    print(passwd)
    print(sex)

def foo(*args,**kwargs):
    print("用户名密码：")
    auth(*args,**kwargs)

foo("xie","123",sex='female')
foo(name="xie",passwd="123",sex='female')
foo("xie","123",'female')

为什么要用函数：

1、解决代码重复的问题

2、统一维护

3、程序的组织结构清晰，可读性强

定义函数：

1、 先定义后使用

2、 def 函数名（参数1，参数2，，，，，）

不写return,返回None

Return一个值，这个值

Return多个值，元组

函数只会执行一次return,一执行就结束。

函数的参数：

形参：

位置参数foo(x,y)

默认参数foo(x,y=1)

实参：

按位置传值foo(1,2)

按关键字传值foo(1,2)

混合传值

实参不要是可变类型数据