更新:
函数的闭包特性: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]