python-函数入门（二）

一、函数对象

什么是函数？

函数是第一类对象，指的是函数名指向的值（函数）可以被当做数据去使用

1.函数的特性

1.函数可以被引用，即函数可以把值赋值给一个变量

def foo():

    print('from foo')

foo()

func=foo    #引用,赋值

func()

print(foo)

print(func)

2.函数可以当做参数传给另一个函数

def hi():

    return "hi yasoob!"

def doSomethingBeforeHi(func):

    print("I am doing some boring work before executing hi()")

    print(func())

doSomethingBeforeHi(hi)

3.可以当做一个函数的返回值

def func(): # func=函数的内地址

    print('from func')

# print(func)

age=10

def bar(x):

    return x

res=bar(age)

print(res)

res=bar(func)

print(res)

4.可以当做容器类型的元素

容器对象（list、dict、set等）中可以存放任何对象，包括整数、字符串，函数也可以作存放到容器对象中

def func(): # func=函数的内地址

    print('from func')

age=10

l=[age,func,func()]

print(l)

二、函数嵌套

函数的嵌套又分为两大类

1.函数的嵌套调用：在调用一个函数的过程中，其内部代码又调用了其他函数

def max2(x,y):

    if x > y:

        return x

    else:

        return y

def max4(a,b,c,d):

    res1=max2(a,b)

    res2=max2(res1,c)

    res3=max2(res2,d)

    return res3

print(max4(1,2,3,4))

2.函数的嵌套定义：一个函数内部又定义了另外一个函数

# from math import pi

# # print(pi)

#

# def circle(radius,action=0):

#     """

#     圆形相关运算

#     :param radius: 半径

#     :param action: 0代表求面积,1代表求周长

#     :return: 面积或者周长

#     """

#     def area(radius):

#         return pi * (radius ** 2)

#

#     def perimiter(radius):

#         return 2 * pi * radius

#

#     if action == 0:

#         res=area(radius)

#     elif action == 1:

#         res=perimiter(radius)

#

#     return res

#

# print(circle(10,0))

# print(circle(10,1))

三、名称空间与作用域

1.什么是名称空间：

　　名称空间就是用来存放名字与内存地址绑定关系的地方（内存空间），但凡要查找值一定要通过名字，访问名字必须去查找名称空间

2.名称空间的三大类

　　内置名称空间：存放的是python解释器自带的名字例如：len（）、man（）等

　　全局名称空间：存放的是文件级别的名字（不是函数内，不是内置的）

x、y、z、b、foo都是全局

m不是

x=1

y=2

if x=1：

    z=3

while Ture：

    b=4

def foo（）：

    m=3

　　局部名称空间：在函数内部定义的

　　生命周期：

　　　　内置名称空间：在解释器启动时生效，关闭时则失效

　　　　全局名称空间：在解释器解释执行python文件时生效，文件执行完毕后则失效

　　　　局部名称空间：只在调用函数时临时产生该函数的局部名称空间

　　加载顺序：内置===》全局===》局部

　　查找名字的顺序：

　　　　基于当前所在位置往上查找，假设当前站在局部，查找顺序：局部==》全局==》内置

　　　　　　　　　　　　　　　　　假设当前站在全局，查找顺序：全局=》内置

注：名字的查找顺序，在函数定义阶段就已经被固定死了（即在检测语法时就已经确定了名字的查找顺序），与函数调用位置无关，无论在任何地方调用函数，都必须回到当初定义函数的位置去确定名字的查找关系

# x=111

# def outer():

#     def inner():

#         print('from inner',x) # x访问的时全局名称空间中x

#     return inner

#

# f=outer()

# # print(f)

#

# x=222

# f()

3.作用域

作用域指的是作用的范围，分为两种，全局作用域和局部作用域

1.全局作用域：包含的是内置名称空间与全局名称空间中的名字

　　特点：全局有效，全局存活

2.局部作用域：包含的是局部名称空间中的名字

　　特点：局部有效，临时存活

补：global 和 nonlocal

#global:在局部声明一个名字是来自于全局作用域的，可以用来在局部修改全局的不可变类型

# x=1

# def foo():

#     global x

#     x=2

#

# foo()

# print(x)

#nonlocal:声明一个名字是来自于当前层外一层作用域的，可以用来在局部修改外层函数的不可变类型

# x=0

# def f1():

#     x=111

#     def f2():

#         nonlocal x

#         x=222

#     f2()

#     print(x)

#

# f1()

# print(x)

四、闭包函数

1.什么是闭包函数？

指的是定义一个函数内部的函数，该内部函数包含对外层函数作用域名字的引用

需要结合函数对象的概念将闭包函数返回到全局作用域去使用，从而打破函数的层级限制。

def outter():

    x=111

    def inner():

        print(x)

    return inner

f=outter() #f=outter内的inner

# x=22222

# f()

def func():

    x=3333

    f()

func()

2.为何要用闭包函数？

闭包函数提供了一种为函数体传值的解决方案

3.如何使用闭包函数

为函数传值的方式有两种，参数和闭包（目前所学）

# 为函数体传值的方式一：参数

# def func(x,y):

#     print(x+y)

#

# func(1,2)

# 为函数体传值的方式二：闭包

# def outter(x,y):

#     # x=1

#     # y=2

#     def func():

#         print(x+y)

#     return func

#

# f=outter(1,2)

# f()