python学习笔记——4. 函数

更新：

函数的闭包特性：1,发生在嵌套函数中；2,内层函数用到了外层函数的变量；3,外层函数返回了内部函数的函数名

def Hanshu1(b):
    a = 3
    def Hanshu2(c):
        print(a+b+c)
    return Hanshu2
x = Hanshu1(7)
x(2)
x(6)

有闭包作用的装饰器：

# 装饰器会将内部函数包装并返回，“@语法糖”下面第一个函数即为被装饰的函数
# 装饰器有关知识详见https://www.cnblogs.com/cicaday/p/python-decorator.html
def decor(func):
     print("third")
     def neibu():
         print("forth")
         func()
         print("fifth")
     return neibu
@decor
def jisuan():
    print("first")
    he = 0
    i = 0
    while i < 3:
        he += i
        i  += 1
    print("second")
jisuan()

def debug(func):
    def wrapper():
        print("k")
        return func()
    return wrapper

@debug
def say_hello():
    print("kk")
jisuan()
say_hello()

#装饰器和对应函数绑定，在定义后无论调用几次都会给出一样的结果。

关于参数的位置问题：

python因为没有主函数，在读取程序时会从程序开头一直往下读，直到读到函数调用或操作再进行运算。故，如果参数在被调用前如果多次被改值，那么以函数调用前最后一次的值为准。

如下面两个示例代码：

key = 0
def use()
    print(key)
key = 1
use()
# key>>1

begin：
def use()
    print(key)
key = 1
use()
#正常执行，因key在函数调用前创建 key>>1

begin:
def use()
    print(key)
use()
key = 1
#不正常执行，因为key在函数调用后创建

最近新学习到了一种函数调用方式：另一个函数的指针作为内置函数进行操作。

如下图的代码：

在这段代码中，max函数把另一个函数func_max()作为内置函数进行操作。同样的，sort()等函数也能这样调用其他函数进行操作。在这类函数中都用key字段存储相应函数的地址。

#将一串数字按绝对值排序
nums = [1, -2, 3, 7, -9, 11, -8]
answer = sort(nums, key = abs)
>>[1, -2, 3, 7, -8, -9, 11]

————————————————————更新线—————————————————————————————————

在学习python后，就要树立一个万物皆指针的意识，比如本章将要说的python中的函数：

因为在py中变量不需要提前声明，即“变量”可以理解为是可以指向任何类型实例的指针，因函数也有地址，故也可以指向函数

# 用def定义新函数
def add(x, y):
    print("x is {} and y is {}".format(x, y))
    return x + y    # 用return语句返回

# 调用函数
add(5, 6)   # => 印出"x is 5 and y is 6"并且返回11

# 也可以用关键字参数来调用函数
add(y=6, x=5)   # 关键字参数顺序不重要，函数将接收到正确的参数


# 我们可以定义一个可变参数函数
def varargs(*args):
    return args

varargs(1, 2, 3)   # => (1, 2, 3)


# 我们也可以定义一个关键字可变参数函数
def keyword_args(**kwargs):
    return kwargs

# 我们来看看结果是什么：
keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}


# 这两种可变参数可以混着用
def all_the_args(*args, **kwargs):
    print(args)
    print(kwargs)
"""
all_the_args(1, 2, a=3, b=4) prints:
    (1, 2)
    {"a": 3, "b": 4}
"""

# 调用可变参数函数时可以做跟上面相反的，用*展开序列，用**展开字典。
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)   # 相当于 foo(1, 2, 3, 4)
all_the_args(**kwargs)   # 相当于 foo(a=3, b=4)
all_the_args(*args, **kwargs)   # 相当于 foo(1, 2, 3, 4, a=3, b=4)


# 函数作用域
#legb法则：
# 查找参数的顺序：局部变量 > 外部局部变量 > 全局变量 > python内置作用域
x = 5
def setX(num):
    # 局部作用域的x和全局域的x是不同的
    x = num # => 43
    print (x) # => 43

def setGlobalX(num):
    global x # global语句作用是表示这个变量名不是局部的，而是全局的
    print (x) # => 5
    x = num # 现在全局域的x被赋值
    print (x) # => 6

setX(43)
setGlobalX(6)



# 函数嵌套：在一个函数中定义了另一个函数
#函数有可见范围，这就是作用域的概念，内部函数不能被外部直接使用，会抛NameError异常
def create_adder(x):
    def adder(y):
        return x + y
    return adder      #关键语句，只有通过return内部函数adder的地址才能让外部利用该函数

add_10 = create_adder(10)#自此add_10指向adder函数
add_10(3)   # => 13

# 也有匿名函数
x = lambda y : y > 3
print(x(3))

#匿名函数的拓展：
a = [lambda x: x*i for i in range(3)]
print(a[0](0), a[0](1), a[0](2))
print(a[1](0), a[1](1), a[1](2))
print(a[2](0))
#此处，在列表的创建过程中创建了一个匿名函数，(0, 1, 2)三个数字都有对应的匿名函数
#且因初始化完成后，i变成了2，故以后调用时函数中的i值即为2

# 内置的高阶函数
map(add_10, [1, 2, 3])   # => [11, 12, 13]
#map(function, iterable, ...)
# 根据提供的函数对指定序列做映射, 以参数序列中的每一个元素调用 function 函数
# 2.x的函数返回列表， 3.x的函数返回迭代器

filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
# filter(function, iterable)
# 用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。


# 用列表推导式可以简化映射和过滤。列表推导式的返回值是另一个列表。
[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]

python学习笔记——4. 函数

猜你喜欢