函数1

函数的定义：
def 函数名():
　　pass

def my_len():
　　ls = [1,2,3,4,11,18]
　　for count in ls:
　　　　count += 1
　　print(count)
函数的调用方法：
函数名()      # 执行函数  函数名()

函数的优点：
减少代码的重复率；
增强代码的阅读性。

函数到底是什么？函数最主要的目的：封闭一个功能。


函数的返回值: 要用到 return 语句

# 函数的声明： def 函数名():
def my_len():      # 这个函数没有返回值
    ls = [1,2,3,4,11,18]
    for count in ls:
        count += 1
    print(count)
my_len()
result = my_len()  # 函数没有返回值，用一个变量去接收结果，就是：None
print(result)   # 输出结果： None

# 要让函数返回址，就要用到 return 语句， return 值  ；若没有，没有跟值 ，返回值 也是 None

# return 后面没有跟值的情况：
def demo1():
    a = 5
    return
print(demo1())   # None

# return 后面跟一个值 的 情况：
def demo2():
    a = 5
    return a
result = demo2()
print(result,type(result))  # 5 <class 'int'>

def demo3():
    tu = (1,3,'abc')
    return tu
result = demo3()
print(result,type(result))  # (1, 3, 'abc') <class 'tuple'>
# return 后面跟一个值的情况总结：值是什么类型，返回也相应的类型。即原封不动地返回。

# return 后面跟多个值的情况： 值 与 值 之间以‘逗号’分割

def demo4():
    x = 5
    y = 'hello world'
    dic = {'name':'chris'}
    return x,y,dic
ret = demo4()  # 整体是函数的执行者。在工作中，函数中尽量不要出现print
print(ret,type(ret))   #  (5, 'hello world', {'name': 'chris'}) <class 'tuple'>

# 可见，如果return 返回多个值的情况，将return 后面的值，放进一个元组，整个返回

# 由于返回的是一个元组，可以分别赋值
x,y,dic = demo4()   # 分别赋值时， = 号两边的元素个数相同，一一对应
print(x,y,dic)      # 5 hello world {'name': 'chris'}

 函数的参数：

# 函数的传参：
# 实参
#       位置参数：   按照顺序，一一对应
#       关键字参数： 可以不按照顺序，但是必须一一对应
#       混合参数： 关键字参数一定要在位置参数后面
# 形参
#       位置参数：按照顺序，一一对应
#       默认参数：
l1 = [1,3,5,7,9,11]
s = "jump river haha"
def obj_len(argv):  # 形式参数，形参
    # 函数体
    count = 0
    for item in argv:
        count += 1
    return count
length = obj_len(l1)  # 函数的执行者（实参） 实际的参数
print(length)  # 6
length = obj_len(s)    # 函数的执行者（实参） 实际的参数
print(length)  # 15

#实参 之 位置参数：

def func1(x,y):
    print(x,y)
func1(1,2)   #  通过位置传参数，一一对应， 1 传给形参 x , 2 传给形参 y.
# 2个函数，1个函数 求和；2个函数 将大的数给我返回
def sum1(x,y):
    return x + y
a = 10
b = 15
print(sum1(a,b))

def compare(x,y):
    return x if x > y else y    # 三目运算符
x = 3
y = 2001
print(compare(x,y))
# 三元运算符：只针对简单的if else 这样的结构，才可以使用。

# 关键字参数，可以不按照顺序，但是必须一一对应。
def func2(x,y):
    return x == y           # return后面，可以是关系表达式，但不能是赋值表达式
print(func2(y=10,x=7))

# 混合传参： 关键字参数一定要在位置参数后面。
# def func3(a,y,n,x,n):    # 在函数的定义中，不能有相同的参数 SyntaxError: duplicate argument 'n' in function definition
#     return a,y,x,n
# name = 'chris'
# print(func3(100,200,'chris',x=18,n=28))

# def func3(a,y,n,x,n1):
#     return a,y,x,n
# name = 'chris'
# print(func3(100,200,'chris',x=18,n1=28))

# 形参角度
#       位置参数：按照顺序，一一对应
#       默认参数： 给其传值，将原来默认值给覆盖掉，不传值，不报错，使用默认值
#                   应用场景：不经常改变的参数，但是一直在用。
def func4(x,y,z=100):
    return x, y, z
print(func4(10,20)) # (10,20,100)
print(func4(10,20,150)) # (10,20,150)

 形参中的 默认参数：

# def test(x,y=15,z):    # 报错：SyntaxError: non-default argument follows default argument
#     print(x,y,z)
# test(10,z=18)

# 经过测试，总结出来，在函数定义时，形参中的默认参数，要放在最后，即非默认参数，不能跟随在默认参数后面
def test(x,z,y=15):    # 报错：SyntaxError: non-default argument follows default argument
    print(x,y,z)
test(10,y=15,z=18)  # 打印10 15 18

def test(x,y=15,z=10):    # 报错：SyntaxError: non-default argument follows default argument
    print(x,y,z)
test(10,z=18)   # 打印10 15 18

def test(x,y=15,z=10):    # 报错：SyntaxError: non-default argument follows default argument
    print(x,y,z)
test(10,18)  # 打印 10 18 10

 形参中的默认参数陷井：

# 形参中的默认参数陷井

def trap(arg1,arg2=[]):
    arg2.append(arg1)
    return arg2
ret1 = trap(15)
ret2 = trap(100)
ret3 = trap(101)
print(ret3)  # [15,100,101]
print(id(ret1),id(ret2),id(ret3))   # 指向同一个内存地址 2196520805000 2196520805000 2196520805000
# 总结： 当默认参数是可变数据类型时，她始终使用一个

写一个不函数：输入学生信息：

def add_record(name,sex):
    with open('students',encoding='utf-8',mode='a+') as f1:
        f1.write(name + "----" + sex + '
')
        print("{}-----{} 添加成功".format(name,sex))
        f1.close()

print("欢迎来到学生信息录入系统！！！")
while 1:
    select = input("请输入，任意键继续，Q退出>>>")
# 为了做兼容性，怕用记输入中文的逗号，对接收的字符串作一个替换操作，变为英文的逗号，再以逗号 分割，得到一个列表
    if select.upper() != 'Q':
        name,sex = input("请输入学生的姓名和性别，以逗号作为分割>>>").strip().replace('，',",").split(",")
        add_record(name,sex)
    else:
        break

动态参数，也叫万能参数：

# 你的函数为了拓展，对于传入的实参数量不固定，这时就要用万能参数，又叫动态参数， *args, **kwargs.
def function1( *args,**kwargs):
    print(args)
    print(kwargs)
function1(1,3,[1,3,5],x=10,y=20,name='chris')   #  (1, 3, [1, 3, 5])
                                                # {'x': 10, 'y': 20, 'name': 'chris'}

 # 总结一下：在函数定义中，万能参数或叫动态参数   一颗星 或 二颗星 后面的 变量名字，可以任意取，
 # 只不过，给定俗成取为 args  和  kwargs 。
 # 在函数的定义中， 形参中的 星号  是 聚合 的作用。
 #   一颗星 将函数调用时，实参中的所有位置参数 ，聚合到一个元组中，然后将该 元组 赋值给 一颗星 后面的变量名
 #   二颗星 的作用 是在函数调用时，将实参中的关键字参数，以键值对的形式，聚合到字典中，然后将字典赋值给 二颗星 后面的 变量名

 # * 号的魔法作用，在函数调用时， * 的作用是 打散   的作用
一颗星 * 把迭代对象打散成为 实参中的位置参数  ；  二颗星 ** 把字典 打散成 实参中的 关键字参数


l1 = [1,2,3,5]
l2 = [11,22,33,'chris']

def func1(*args):
    return args[0] + args[1]
print(func1(l1,l2))  #  [1, 2, 3, 5, 11, 22, 33, 'chris']

def func1(*args):  # 定义一个聚合实参的位置参数的变量
    return args
print(func1(*l1,*l2))  # (1, 2, 3, 5, 11, 22, 33, 'chris')
              # 这里 * 号起到打散的作用，将可迭代对象，打散成一个个元素5
              # 相当于 func1(1,2,3,5,11,22,33,'chris')

l3 = [[1,2,{'name':'chris'}],99,88]
print(func1(*l3))  #  ([1, 2, {'name': 'chris'}], 99, 88)  只是将第一层打散
dic = {'name':'chris','age':18,'sex':'male'}
print(func1(*dic))  #  ('name', 'age', 'sex')  一颗星 ，对字典打散，打散成一个个键 

def func2(**kwargs):
    print(kwargs)
dic = {'name':'chris','age':18,'sex':'male'}
func2(**dic)         # 函数调用时， 二颗星，将后面字典中的键值对，打散成关键字参数传参
                     # 相当于 func2(name='chris',age=18,sex='male)

func2(name='chris',age=18,sex='male')
func2(*dic)   # 报错： TypeError: func2() takes 0 positional arguments but 3 were given

形参的顺序：

# 位置参数，默认参数，*args,**kwargs

# 位置参数，默认参数
# def func(a,b,sex='男'):
#     # print(a)
#     print(sex)
# func(100,200,)
# 位置参数，*args, 默认参数
# def func(a,b,*args,sex='男',):
#     # print(a)
#     print(a,b)
#     print(sex)
#     print(args)
# func(100,200,1,2,34,5,6)

# 位置参数，*args, 默认参数 **kwargs
# def func(a,b,*args,sex='男',**kwargs,):
#     print(a,b)
#     print(sex)
#     print(args)
#     print(kwargs)
# func(100,200,1,2,34,5,6,sex='nv',name='alex',age=1000)

=========================================================================================================
def test(x,y,z=10,**kwargs):
    print(x)
    print(y)
    print(z)
    print(kwargs)
test(11,22,name='jia',age=18)


def test(x,y,**kwargs,):  # 两颗星 修饰的 聚合变量 放到形参最后，规则
    print(x)
    print(y)

    print(kwargs)
test(11,22,name='jia',age=18)

def test(x,z,y=100):   # 函数定义时，默认参数放在最后
    return x + y + z
#print(test(100,2))     # SyntaxError: non-default argument follows default argument 非默认参数不能跟随默认参数后
print(test(x=100,z=100))
print(test(100,200))