python学习笔记(七)函数使用

函数使用

变量作用域的验证

示例：

name = 'dahua'

# 查看当前命名空间下所有可以使用的全局变量
print(globals())
# 查看当前命名空间下所有可以使用的局部变量
print(locals())
# 测试获取函数中的局部遍历
def test():
    a = 250
    print(locals())

test()
# 结果应为  {'a': 250}

偏函数

说明：固定函数参数的默认值，简化函数完成特定的功能

示例：

# 表示以二进制的方式 1010
a = int('1010', base=2)
print(a)
# 结果为 10

# 封装方法
def int2(n):
	return int(n, base=2)

b = int2('1001')
print(b)

# 需要进行导入
import functools
# 创建偏函数
# 本质就是固定函数参数的默认值，简化函数调用时的参数构造
int8 = functools.partial(int, base=8)
c = int8('12')
print(c)

匿名函数

预备知识

def test():
    print('for test')
    
# 函数的名字
print(test.__name__)

# 可以像普通变量一样赋值
a = test
print(a.__name__)

# 二者的效果一样
test()
a()

def demo(func):
	func()   
    
# 函数可以为其他函数的参数
demo(test)

匿名函数的使用

场景：当一个函数作为另一函数的参数时，若改函数非常简单，而且只使用一次，先定义函数，然后作为参数传递没有必要，可以通过匿名函数进行解决。
格式：lambda 参数列表: 表达式
参数列表：书写形式与函数的参数列表相同
表达式：就是匿名函数的返回值，不需要使用return关键字
示例：

def calc(a, b, yunsuan):
    return yunsuan(a, b)

def add(a, b):
    return a+b

print(calc(3, 5, add))
print(calc(3, 5, lambda a, b: a+b))
print(calc(3, 5, lambda a, b: a*b)) 

优点：
使用简洁，不用单独的定义函数，可以在调用的函数参数中直接书写
使用完毕后自动释放，节约内存空间
列表排序

# lt = [3, 6, 2, 1, 8, 4]
lt = [
    {'name': 'dahua', 'age': 18, 'height': 175},
    {'name': 'erhua', 'age': 17, 'height': 165},
    {'name': 'dagou', 'age': 22, 'height': 185},
    {'name': 'ergou', 'age': 21, 'height': 180}
]


def key(dt):
    return dt['age']

# lt.sort(key=key)
# 通过height的值进行排序 使用匿名函数的方式
lt.sort(key=lambda dt: dt['height'])

for i in lt:
    print(i)

闭包

闭包有一点难以理解
定义：

外部函数中定义一个内部函数
内部函数中使用外部函数的局部变量
外部函数将内部函数作为返回值返回
返回的函数就称为闭包
示例：

def wai(n):
    # 定义一个内部函数
    def nei():
        # 使用外部函数的局部变量
        return n*n
    # 将内部函数作为返回值返回
    return nei

# f1、f2都是闭包
f1 = wai(3)
f2 = wai(5)

print(f1())
print(f2())

总结：闭包可以认为是具有执行环境的函数

装饰器

装饰器用处很大
作用：当需要修改函数功能时，不能或不想改原函数，可以通过装饰器进行解决。

使用：

装饰器其实就是一个函数，该函数有一个参数是函数类型，返回值是一个闭包
在闭包中调用传递进来的函数，在调用函数的前后都可以添加内容
示例：

def zhuangshiqi(func):
    def wrapper():
        print('=====')
        func()
        print('*****')
    return wrapper

@zhuangshiqi # 相当于执行了 test = zhuangshiqi(test)
def test():
	print('for test')
    
# test()
# t2 = zhuangshiqi(test)
# t2()
# test = zhuangshiqi(test)
test()
标准装饰器

# 装饰任意的函数：参数与返回值不限
def zhuangshiqi(func):
    def wrapper(*args, **kwargs):
        print('前面装饰')
        result = func(*args, **kwargs)
        print('后面装饰')
        return result
    return wrapper

def test():
	print('for test')
	# 没有进行装饰  名字是test
	print(test.__name__)

@zhuangshiqi # 被装饰后名字就会发生改变
def test():
	print('for test')
	# 装饰后名字发生改变  wrapper
	print(test.__name__)

# test()

@zhuangshiqi
def show(a, b):
	# print(a, b)
  	return a+b
  
print(show(1, 2))

函数名字修正

import functools

def zhuangshiqi(func):
    # 专门用来修正被装饰的函数的名字
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('前面装饰')
        result = func(*args, **kwargs)
        print('后面装饰')
        return result
    # 修正装饰之后的函数名，不够优雅
    # wrapper.__name__ = func.__name__
    return wrapper 

@zhuangshiqi
def test():
	print('test func')
      
test()
print(test.__name__)

今天的学习到此结束！！！