python函数及文件操作

定义函数的三种形式

- 无参数函数，通常无返回值
- 有参数函数，函数的功能执行依赖外部传入的参数，有参数函数通常有返回值
    def add(x,y):
        sum=x+y
        return sum
- 空函数
def insert():
    pass

函数返回值

- 返回值为None
    没写return
    return 啥也不接
    return None
- 一个返回值
    def foo():
        return x
- 多个返回值
    return 值1，值2，值3，值4 --->返回结果组成tuple

调用函数

def dog():
    print(‘dog‘)

def cat(cat):
    print(‘===>‘,cat)

dog()
cat(‘加菲‘)

调用函数的三种方式：

- dog() #直接调用
- 调用函数的表达式形式
    def add(x,y):
        sum=x+y
        return res
    res=add(3,5) * 1000

- 把函数调用当中另外一个函数的参数
    res=max(max(3,5),7)

函数的参数:

- 形参 定义函数时的参数名称
- 实参 调用函数时传入的参数

详细区分函数的参数

- 位置参数
    def foo(x,y,z):
        print(x,y,z)

    foo(1,2,3) 实参位置和形参位置一一对应

- 关键字参数：
    def foo(x,y,z)
        print(x,y,z)

    foo(z=3,y=1,x=4)
    foo(1,z=3,y=5)

    注意点：
        1. 关键字实参必须在未知实参后面
        2. 不能重复对一个形参传值

- 默认参数
    def reg(name,age,sex=‘male‘):
        print(name,age,sex)

    注意点：
        1. 定义函数时，默认参数必须在非默认参数之后
        2. 默认参数在定义阶段智能赋值一次
        3. 默认参数通常定义成不可变类型

- 可变长参数，
    1. *会把溢出的按位置定义的实参都接受，以元组形式赋值给args
    def foo(x,y,*args):
        print(x,y)
        print(args)
    foo(1,2,3,4,5,6)
    输出:
        1 2
        (3,4,5,6) tuple形式

    2. def foo(x,y,**kwargs):**会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
           print(x,y)
           print(kwargs)
       foo(1,2,c=2,name=‘lh‘,age=18)

    输出:
        1 2
        {‘c‘: 2, ‘name‘: ‘lh‘, ‘age‘: 18}

    例子:
        def foo(name,age=10,*args,sex=‘male‘,height,**kwargs):
            print(name)
            print(age)
            print(args)
            print(sex)
            print(height)
            print(kwargs)
        foo(‘alex‘,1,2,3,4,5,sex=‘female‘,height=‘150‘,a=1,b=2,c=3)

        输出:
            alex
            1
            (2, 3, 4, 5)
            female
            150
            {‘c‘: 3, ‘a‘: 1, ‘b‘: 2}

        def foo(x,y,z):
            print(‘from foo‘,x,y,z)
        def wrapper(*args,**kwargs):
            print(args)
            print(kwargs)
            foo(*args,**kwargs)

        # wrapper(1,2,3,a=1,b=2)
        wrapper(1,z=2,y=3)

        输出:
            （1，）
             {‘z‘:z,‘y‘:3}
             from foo 1 3 2