函数1

day20

为什么要用函数：

    解决代码重用问题

    统一维护

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

不用函数：

    代码冗余

    可读性差

    可维护性，扩展性差

初始函数：

内置函数：print, sum, max, len ......

自定义函数：

结构：

函数名(,,):
    函数体
    返回值

如：

# 自定义一个print_line()函数
def print_line():
    print("#" * 15)
    
# 自定义一个print_msg()函数
def print_msg():
    print("Are you ok?")
    
# 函数调用
print_line()
print_msg()
print_line()

函数的定义和调用：

# 定义函数：三种形式
# 1.无参函数
def foo():
    "无参函数"
    print("this is foo")

# 2.有参函数：定义时有参，调用时也一定要传入参数
def bar(x,y):
    "有参函数"
    print(x)
    print(y)

# 3.空函数
def auth():
    "空函数"
    pass
    

# 函数调用
foo()
res = bar(1, 2)

语句形式：foo()
表达式形式: res=10*my_sum(1,2)
函数调用作为另一个函数的参数: print(my_sum(1,2))

函数的返回值：

def bar(x, y):
    sum_xy = x + y
    return sum_xy

res = bar(1, 2)
print(res)


def foo():
    print("from foo")

res2 = foo()
print(foo())    # 返回None

插入知识：变量解压

# 返回多个值
def newbar(x, y):
    return 1, 2, 3


res3 = newbar(1, 2)  # 返回的是元组
print(res3)

a, b, c = newbar(1, 2)  # 分别的到每一个值
print(a)
print(b)
print(c)

总结：

函数的返回值可以返回任意类型的返回值

不写return，默认返回None

return一个值，返回的就是一个值

return多个值，返回的是由这多个值组成的一个元组

形参和实参：

行参：形式参数，指函数在定义时括号里写的参数，本质就是变量名

实参：实际参数，指在函数调用时括号里写的参数，本质就是变量值，实参必须要有一个明确的值，可被当成变量值

实参需为不可变类型，要不然还函数内改了变量的值会有不可预测的问题，避免传入可变类型的参数。

位置参数与默认参数：

以下面函数为例：

def foo(x,y):

print(x)

print(y)

从实参的角度，实参有三种传值形式：

1. 按位置传值

foo(1,2)

2. 按关键字传值

foo(x=1,y=2)

3. 混着用

foo(1,y=2)

foo(y=2,1)  # 会报错

注意：

按位置传值必须在按关键字传值的前面

对于一个参数只能赋值一次

从形参的角度：

位置参数：必须传值的参数

def foo(x,y):

    print(x)

    print(y)

 foo(1,2)

默认参数：定义时赋值，默认参数必须放到位置参数的后面

def foo(x,y=1):

    print(x)

    print(y)

foo(1)

def foo(y=1,x)  # 会报错

可变参数：

*args

def foo(x, *args):

    print(x)

    print(args)

foo(1, 2, 3, 4, 5, "a", "b")

按位置传值，正常输出1，其他多余的参数全部交给*args,并已元组的形式输出

运行结果：

1

(2, 3, 4, 5, 'a', 'b')

应用场景，如写一个sum函数：

# *args与位置参数和默认参数混用

def foo(x, y=1, *args):

    print(x)

    print(y)

    print(args)

foo(1, 2, 3, 4, 5)

运行结果：

1

2      <<<<注意这个结果

(3, 4, 5)

# 正确使用：

顺序：位置参数，*args，默认参数

def foo(x, *args, y=1):

    print(x)

    print(y)

    print(args)

foo(1, 2, 3, 4, 5, 6, 7, 8, 9)

运行结果：

1

1

(2, 3, 4, 5, 6, 7, 8, 9)

**kwargs

def foo(x, **kwargs):

    print(x)

    print(kwargs)

foo(1, y=2, a=3, b=4)

运行结果：

会把按位置传值剩下的多余的参数转为字典

1

{'y': 2, 'a': 3, 'b': 4}

# 混着用的位置问题

def foo(x,*args,**kwargs):

    print(x)

    print(args)

    print(kwargs)

foo(1,y=1,z=2)

运行结果：

1

()

{'y': 1, 'z': 2}