Python之函数

Python之函数

　　

　　一、为什么要用函数：

　　　　在大量的代码块的前提下，会后很多相同的功能调用，会导致简单的代码被多次重用。

　　　　所用会有代码冗余的问题，无法统一管理，可维护性差。　　

　　函数分为内置函数和自定义函数。　

 

　　二、如何定义函数：　　　　

def test(*args,**kwrags):
    """
    函数功能的注释
    """
    print('#'*13)   #函数体
　　return    #返回值，可以是任意类型

test()   # 调用函数

 

　　三、函数的参数：

　　　　无参函数：

　　　　　函数只是用来打印一些普通的语句。不需要依赖外部传来的参数就可以运行的函数。

def test():
    print('is test')

　　　　有参函数：

　　　　　函数依赖于外部传来的值。才可以实现函数的调用，需要有返回值。

def test(x,y):
    print(x)
    print(y)

　　　　函数的形参和实参：

　　　　　　形参：就是定义函数时，在括号里的参数。　　　

def test(x,y):    # x,y 就是形参
    pass

　　　　　　实参：就是在调用函数时，传入的参数。实参尽量用不可变类型，字符串，数字，元组。

def test(x,y):
    res = x+y
    return res

ret = test(1,3)    # 1,3就是实参
print(ret)

#实参也可以是变量的形势

def test(x,y):
    print(x)
    print(y)

a=1111
b=2222

test(a,b)   #这里的实参a,b 既是变量的形势，以变量的形势传入到函数test里。

　　　　函数的位置参数，形参的位置参数，实参是位置传参。必须传值。

　　　　　　实参可以按位置传值。

def test(x,y):
    print(x)
    print(y)

test(1,3)   # 实参的位置参数，1就给x, 3就给y   

　　　　　　实参也可以按关键字传值。

def test(x,y):
    print(x)
    print(y)
test(x=1,y=3)     # 实参按关键字传值

　　　　　　关键字传值和位置传值可以混合用

def test(x,y):
    print(x)
    print(y)
test(1,y=3)   

 

　　　　函数的默认参数：在定义函数阶段，就已经定义好值了。默认参数必须放在位置参数后边。

def test(x,y=1):   #y=1 就是定义好的默认参数，在不给y传值的情况下，就用默认的。
    print(x)
    print(y)

test(5)     #在传值时，可以不用给y传值。
test(1,4)  #也可以继续给y传值，只不过，传的值会覆盖已经定义好的值。

　　　　函数的可变参数：（*args,**kwargs）

　　　　*args接收列表和元组类型，**kwargs接收字典类型。

　　　　按位置传值，多余的交给*args处理，处理成元组。

　　　　按关键字传值，多余的交给**kwargs处理成字典。

 

　　　　*args:

def test(x,*args):
    print(x)
    print(args)

test(1,2,3,4,5,6,7,7,'a','b')

 

　　　　**kwargs:

def test(x,**kwargs):
    print(x)
    print(kwargs)

test(1,y=2,z=3)

 

注意：

　　　　一、传参的位置：位置参数 --- *args --- 关键字参数 --- 默认参数 --- **kwargs

　　　　二、对于一个形参，只能赋值一次。

　　　　三、按位置传值，指的是实参。

　　　　四、位置参数，指的是形参。必须传值。

 

　　四、空函数:

　　　　用于项目的体系设计。

def test():
    pass

 

　　五、函数的调用：

　　无参函数在调用时，直接调用即可。

　　有参函数在调用时，加上要传的参数即可。有几个参数位，就传几个参数。

#带参数的函数
def test(x,y):
    print(x,y)
    res = x+y
    return res

ret = test(1,4)  #有参函数的调用
print(ret)

　　

　　六、函数的返回值：

　　　　　　可以返回任意数据类型。

　　　　　　没有return的，返回None。

　　　　　　return 1 ，返回就是1。

　　　　　　return 1，2，3    返回的就是一个元组（1，2，3）

 

　　　　函数在执行到return时，只会执行一个return，并且执行完return就结束这个函数的调用了。

def test():
    """
    不写返回值的情况，结果是None
    :return:
    """
    print('aaaa')

res = test()
print(res)


def test(x,y):
    """
    有返回值的情况, 返回结果
    :param x:
    :param y:
    :return:
    """
    res=x if x>y else y
    return res

res1 = test(1,4)
print(res1)


def test(x,y):
    """
    return可以返回任何数据类型
    :param x:
    :param y:
    :return:
    """

    return 1,2,3,[1,2],{'a':1},{1,2,3}

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

 

　　七、名称空间

　　　　有关名称的定义，都会放在名称空间里。

　　　　名称空间分为三种：内置名称空间、全局名称空间、局部名称空间。

　　　　内置名称空间（全局作用域）：内置在Python解释器里的。

　　　　全局名称空间（全局作用域）：顶头写的变量，就是全局名称。

　　　　局部名称空间（局部作用域）：在函数内部定义使用的。外部使用不了。

 

　　八、作用域

　　　　先局部找，在全局找，最后内置找。没有在报错。

　　　　先定义，后使用。

x=0
def test():
    x=100
    print(x)

test()

 

　　九、函数嵌套

　　　　　函数的嵌套调用：好处是节省代码

　　　　　　　　函数体内部在调用其他的函数

def test1(x,y):
    res = x if x>y else y
    return res

def test2(a,b,c,d):
    res1 = test1(a,b)
    res2 = test1(res1,c)
    res3 = test1(res2,d)
    return res3

print(test2(1,56,2,68))

　　在test2函数里嵌套了test1。

 

　　　　　函数的嵌套定义：就是在函数里再定义函数。

def test1():
    def test2():
        def test3():
            pass

 

def test1():
    print('----test1',x)
　　 x=1
    def test2():
        x=2
        print('------test2',x)
        def test3():
            x=3
            print('----test3',x)
        test3()
　　 test2()
test1()