python之函数

转自：https://www.cnblogs.com/Eva-J/articles/7156261.html

1、函数的定义：

1 def main():
2     #代码

2、函数可以返回一个值，也可以返回多个值。

　返回多个值时：如果用一个变量去接收，返回的是元祖。用多个变量接收，变量的个数要和返回值的个数相同

3、函数参数：定义顺序为：位置参数>可变参数>默认参数>关键字参数

例如：

def func(a,b,*args,c=1,d=2,**kwargs):
    print(a)
    print(b)
    print(args)
    print(c)
    print(d)
    print(kwargs)
func(1,2,'c','d',c=2,k=6,f=9,d=7)

显示结果

1
2
('c', 'd')
2
7
{'k': 6, 'f': 9}

　　PIS：默认参数如果定义为可变参数，默认参数只要不重新赋值（ list = [] 也算重新赋值），list指向的地址永远不变！

def extendList(val, list=[]):
    list.append(val)
    return list
list1 = extendList(100)
print(list1)
list2 = extendList(40, list=[])
print(list2)
list3 = extendList(200)
print(list3)
list4 = extendList(50, list=[])
print(list4)

显示结果：

[100]
[40]
[100, 200]
[50]

4、命名空间：

有三种空间：内置命名空间，全局命名空间，局部命名空间

加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

调用顺序：局部命名空间->全局命名空间->内置命名空间（不可逆）

x = 1
def f(y):
    global x
    print(x)
    print(y)
f(3)

显示如下：

5、作用域

全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效

局部作用域：局部名称空间，只能在局部范围内生效

globals和locals方法:可以在函数内声明，某个变量为全局变量

a = 10
def func():
    global a
    a = 20

print(a)
func()
print(a)

显示：10 20 如果没有global a 显示 10 10 具体看：https://www.cnblogs.com/zzq888/articles/10302702.html

6、函数的嵌套调用

def max2(x,y):
    m  = x if x>y else y
    return m

def max4(a,b,c,d):
    res1 = max2(a,b)
    print(res1)
    res2 = max2(res1,c)
    print(res2)
    res3 = max2(res2,d)
    print(res3)
    
max4(1,2,3,4)

7、函数的嵌套定义

def f1():
    print("in f1")
    def f2():
        print("in f2")

    f2()
f1()

8、函数的本质

函数名本质上就是函数的内存地址

8.1可以被引用

def func():
    print('in func')

f = func
print(f)

8.2可以被当作容器类型的元素使用（加上括号，就是运行函数）

def f1():
    print('f1')


def f2():
    print('f2')


def f3():
    print('f3')

l = [f1,f2,f3]
d = {'f1':f1,'f2':f2,'f3':f3}
#调用
l[0]()
d['f2']()

8.3

可以当作函数的参数和返回值（当成普通变量使用）

9、闭包（内部函数对外部作用域而非全剧作用域的名字进行了引用，则该内部函数称为闭包函数）：

  #1、必须要有一个内嵌函数
  #2、内嵌函数中要对外层函数中的引用（对全局变量的引用不算闭包函数）
  #3、外部函数必须返回内嵌函数的地址

def func():
    name = 'eva'
    def inner():
        print(name)
    return inner

f = func()#返回的是内部闭包函数inner的地址
f()#地址+括号，运行闭包函数

闭包，多层嵌套

def wrapper():
    money = 1000
    def func():
        name = 'eva'
        def inner():
            print(name,money)
        return inner
    return func

f = wrapper()
i = f()
i()

以下不属于闭包（对全局变量引用了）

#输出的__closure__为None ：不是闭包函数
name = 'egon'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()